Merge remote-tracking branch 'origin/master'

bug fix equip multi

.idea/misc.xml

@@ -1,7 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectPlainTextFileTypeManager">
-    <file url="file://$PROJECT_DIR$/sharpening.py" />
-  </component>
   <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.7 (lc-py-b)" project-jdk-type="Python SDK" />
 </project>

combine_main.py

@@ -1,202 +0,0 @@
-import random
-from time import time
-from window_capture import WindowCapture
-from vision import Vision
-import cv2 as cv
-import pytesseract
-from hsvfilter import HsvFilter
-from config_file import UserConfigs
-# import pyautogui
-import pydirectinput
-import keyboard
-
-
-def run():
-    # initialize the user-class
-    config = UserConfigs()
-
-    # initialize the StunWindowCapture class
-    try:
-        capture_window = WindowCapture(
-            None, "magic", config)
-        video_mode = False
-    except:
-        # StunWindowCapture.list_window_names()
-        # print("Game not running, switching to video mode")
-        # capture_window = cv.VideoCapture("snip_slam.mp4")
-        video_mode = True
-
-    # initialize the StunVision class
-    vision_stun = Vision()
-    # initialize the StunOverlay class
-    hsv_filter_orange = HsvFilter(10, 156, 0, 17, 255, 255, 0, 0, 0, 0)
-    hsv_filter_p = HsvFilter(130, 156, 0, 179, 255, 255, 0, 0, 0, 0)
-    hsv_filter_b = HsvFilter(88, 156, 0, 128, 255, 255, 0, 0, 0, 0)
-    hsv_filter_g = HsvFilter(34, 156, 0, 74, 255, 255, 0, 0, 0, 0)
-    hsv_filter_y = HsvFilter(24, 156, 0, 33, 255, 255, 0, 0, 0, 0)
-    hsv_filter_0 = HsvFilter(0, 0, 0, 179, 255, 255, 255, 0, 0, 0)
-    hsv_filter_w = HsvFilter(69, 25, 0, 94, 255, 255, 0, 0, 0, 0)
-
-    loop_time = time()
-    pause = True
-
-    magic_list = {"1": "body", "2": "finding", "3": "mind", "4": "perceiving", "5": "physical", "6": "seeing",
-                  "7": "spiritual"}
-    tier_list = {"1": "0", "2": "orange", "3": "y", "4": "g", "5": "b", "6": "p"}  # , "w"}
-    hsv_filter_list = {"1": hsv_filter_0, "2": hsv_filter_orange, "3": hsv_filter_y, "4": hsv_filter_g,
-                       "5": hsv_filter_b, "6": hsv_filter_p}
-
-    needle_list = []
-    hsv_list = []
-    for key1 in tier_list:
-        for key2 in magic_list:
-
-            needle_list.append(cv.imread("magic/" + magic_list[key2] + "_" + tier_list[key1] + ".jpg",
-                                                  cv.IMREAD_UNCHANGED))
-            hsv_list.append(hsv_filter_list[key1])
-
-
-    while True:
-        if keyboard.is_pressed('p') == True:
-            pause = True
-            print('q pressed')
-        elif keyboard.is_pressed('o') == True:
-            pause = False
-            print('o pressed')
-        if pause:
-            # cv.waitKey(500)
-            print("pausing")
-            continue
-
-        if video_mode:
-            break
-        else:
-            try:
-                # get an updated image of the game
-                screenshot = capture_window.get_screenshot()
-                # screenshot = cv.imread("buffbar.jpg")
-            except:
-                capture_window.release()
-                print("Game window not available - shutting down application")
-                break
-        #cv.imshow("screenshot", screenshot)
-        #cv.waitKey(150)
-        #continue
-
-        spawn_1 = vision_stun.find(screenshot, cv.imread("magic/spawn_1.jpg", cv.IMREAD_UNCHANGED), 0.25, 1)
-        if len(spawn_1) == 1:
-            spawn_button_active = True
-            points = vision_stun.get_click_points(spawn_1)
-            for i in range(0, 100, 1):
-                pydirectinput.moveTo(points[0][0], points[0][1])
-                pydirectinput.mouseDown()
-                w = random.randint(1, 50)
-                cv.waitKey(30 + w)
-                pydirectinput.mouseUp()
-        else:
-            spawn_0 = vision_stun.find(screenshot, cv.imread("magic/spawn_0.jpg", cv.IMREAD_UNCHANGED), 0.7, 1)
-            points = vision_stun.get_click_points(spawn_0)
-            for point in points:
-                pydirectinput.moveTo(point[0], point[1])
-                pydirectinput.mouseDown()
-                cv.waitKey(500)
-                pydirectinput.mouseUp()
-            continue
-
-        # for needles in needle_list:
-        for rer in range(0, len(needle_list), 1):
-        #for needle in needle_list:
-            # do object detection
-            # processed_image = vision_stun.apply_hsv_filter(screenshot, hsv_filter)
-            # screenshot = capture_window.get_screenshot()
-            #cv.imshow("output_image", needle_list[rer])
-            #cv.waitKey(150)
-
-            while True:
-                screenshot = capture_window.get_screenshot()
-                processed_screenshot = vision_stun.apply_hsv_filter(screenshot, hsv_list[rer])
-                processed_needle = vision_stun.apply_hsv_filter(needle_list[rer], hsv_list[rer])
-
-                #cv.imshow("output_image", processed_screenshot)
-                cv.imshow("output_needle", processed_needle)
-                cv.waitKey(150)
-
-                rectangles = vision_stun.find(processed_screenshot, processed_needle, 0.7, 2)
-                # draw the detection results onto the original image
-                #output_image = vision_stun.draw_rectangles(screenshot, rectangles)
-                #cv.imshow("output_image", output_image)
-                #cv.waitKey(150)
-
-                # only trigger ocr reading if a stun is detected
-                points = vision_stun.get_click_points(rectangles)
-                if len(points) == 2:
-                    pydirectinput.moveTo(points[0][0], points[0][1])
-                    pydirectinput.mouseDown()
-                    w = random.randint(1, 100)
-                    cv.waitKey(250 + w)
-                    pydirectinput.moveTo(points[1][0], points[1][1])
-                    pydirectinput.mouseUp()
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-                else:
-                    break
-                if keyboard.is_pressed('p') == True or pause == True:
-                    pause = True
-                    break
-            if keyboard.is_pressed('p') == True or pause == True:
-                pause = True
-                break
-
-        needles_white = []
-        needles_white.append(cv.imread("magic/body_w.jpg", cv.IMREAD_UNCHANGED))
-        needles_white.append(cv.imread("magic/finding_w.jpg", cv.IMREAD_UNCHANGED))
-        needles_white.append(cv.imread("magic/mind_w.jpg", cv.IMREAD_UNCHANGED))
-        needles_white.append(cv.imread("magic/perceiving_w.jpg", cv.IMREAD_UNCHANGED))
-        needles_white.append(cv.imread("magic/physical_w.jpg", cv.IMREAD_UNCHANGED))
-        needles_white.append(cv.imread("magic/seeing_w.jpg", cv.IMREAD_UNCHANGED))
-        needles_white.append(cv.imread("magic/spiritual_w.jpg", cv.IMREAD_UNCHANGED))
-
-        for needle_w in needles_white:
-            # do object detection
-            screenshot = capture_window.get_screenshot()
-            processed_screenshot = vision_stun.apply_hsv_filter(screenshot,hsv_filter_w)
-            processed_needle = vision_stun.apply_hsv_filter(needle_w, hsv_filter_w)
-            rectangles = vision_stun.find(processed_screenshot, processed_needle, 0.7, 1)
-            # draw the detection results onto the original image
-            # output_image = vision_stun.draw_rectangles(screenshot, rectangles)
-            # cv.imshow("output_image", output_image)
-            # cv.waitKey(150)
-
-            points = vision_stun.get_click_points(rectangles)
-            if len(points) >= 1:
-                pydirectinput.moveTo(points[0][0], points[0][1])
-                pydirectinput.mouseDown()
-                w = random.randint(1, 100)
-                cv.waitKey(100 + w)
-                pydirectinput.mouseUp()
-                screenshot = capture_window.get_screenshot()
-                rectangles = vision_stun.find(screenshot, cv.imread("magic/collect.jpg", cv.IMREAD_UNCHANGED), 0.8, 1)
-                points = vision_stun.get_click_points(rectangles)
-                if len(points) >= 1:
-                    pydirectinput.moveTo(points[0][0], points[0][1])
-                    pydirectinput.mouseDown()
-                    w = random.randint(1, 100)
-                    cv.waitKey(100 + w)
-                    pydirectinput.mouseUp()
-
-                if keyboard.is_pressed('p') == True or pause == True:
-                    pause = True
-                    break
-            if keyboard.is_pressed('p') == True or pause == True:
-                pause = True
-                break
-
-        # debug the loop rate
-        print('FPS {}'.format(1 / (time() - loop_time)))
-        loop_time = time()
-        cv.waitKey(150)
-
-
-if __name__ == "__main__":
-    run()

combined_bot_main.py

@@ -0,0 +1,84 @@
+import sys
+import cv2 as cv
+from combined_user_interface import PrimaryOverlay
+from equipment import Equipment
+from crops import Crops
+from farm import Farm
+from magic import Magic
+from craft import Craft
+from mine import Mine
+from sodoku import Sodoku
+from fruit import Fruit
+from pickaxe import Pickaxe_Field
+from litris import Litris
+from menti_words import MentiWords
+from flappy import Flappy
+
+
+def run():
+    overlay = PrimaryOverlay()
+
+    while True:
+        if overlay.run_mode == 'stopped':
+            overlay.update_status_label("stopped")
+            overlay.run_mode = 'init'
+            continue
+        elif overlay.run_mode == 'started':
+            cv.waitKey(1000)
+            pass
+        elif overlay.run_mode == 'init':
+            cv.waitKey(1)
+            continue
+        elif overlay.run_mode == 'paused':
+            continue
+        elif overlay.run_mode == 'finished':
+            overlay.update_status_label("finished")
+            overlay.run_mode = 'init'
+            continue
+        elif overlay.run_mode == 'quit':
+            return
+        else:
+            break
+
+        if overlay.rb_int.get() == 1:
+            equip = Equipment(overlay)
+            equip.execute_main_loop()
+        elif overlay.rb_int.get() == 2:
+            crops = Crops(overlay)
+            crops.execute_main_loop()
+        elif overlay.rb_int.get() == 3:
+            farm = Farm(overlay)
+            farm.execute_main_loop()
+        elif overlay.rb_int.get() == 4:
+            magic = Magic(overlay)
+            magic.execute_main_loop()
+        elif overlay.rb_int.get() == 5:
+            craft = Craft(overlay)
+            craft.execute_main_loop()
+        elif overlay.rb_int.get() == 6:
+            mine = Mine(overlay)
+            mine.execute_main_loop()
+        elif overlay.rb_int.get() == 7:
+            fruit = Fruit(overlay)
+            fruit.execute_main_loop()
+        elif overlay.rb_int.get() == 8:
+            sodo = Sodoku(overlay)
+            sodo.execute_main_loop()
+        elif overlay.rb_int.get() == 9:
+            paxe = Pickaxe_Field(overlay)
+            paxe.execute_main_loop()
+        elif overlay.rb_int.get() == 10:
+            ltris = Litris(overlay)
+            ltris.execute_main_loop()
+            ltris.stone_id_thread.run_mode = 'stop'
+        elif overlay.rb_int.get() == 11:
+            menti = MentiWords(overlay)
+            menti.execute_main_loop()
+        elif overlay.rb_int.get() == 12:
+            flappy = Flappy(overlay)
+            flappy.execute_main_loop()
+            flappy.flappy_pos_disc.run_mode = 'stop'
+
+if __name__ == "__main__":
+    run()
+    sys.exit()

combined_user_interface.py

@@ -0,0 +1,375 @@
+# Run tkinter code in another thread
+import threading
+import tkinter as tk
+import game_base_class
+from tkinter import ttk
+from mine_overlay import DiggingOverlay
+
+
+class PrimaryOverlay(threading.Thread):
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+        self.MiningOverlay = DiggingOverlay
+        self.run_mode = 'init'
+
+        self.root = tk.Tk
+        self.rb_frame = tk.Frame
+        self.ButtonFrame = tk.Frame
+        self.parameter_frame = tk.Frame
+        self.parameter_label_frame = tk.Frame
+        self.timing_frame = tk.Frame
+
+        self.rb_int = tk.IntVar
+        self.energy_use = tk.StringVar
+        self.spawn_use = tk.StringVar
+        self.emitter_use = tk.StringVar
+
+        self.EnergyLabel = tk.Label
+        self.EnergyEntry = tk.Entry
+        self.SpawnLabel = tk.Label
+        self.SpawnEntry = tk.Entry
+        self.EmitterLabel = tk.Label
+        self.Emitter_Box = ttk.Combobox
+
+        self.RadioButtons = dict
+        self.RadioButtonNames = ["Equip", "Crops", "Farm", "Magic", "Craft", "Mine", "Fruit", "Sodo", "PAxe", "Ltris", "Menti", "Flapp"]
+        self.RadioButton1 = tk.Radiobutton
+        self.RadioButton2 = tk.Radiobutton
+        self.RadioButton3 = tk.Radiobutton
+        self.RadioButton4 = tk.Radiobutton
+        self.RadioButton5 = tk.Radiobutton
+        self.RadioButton6 = tk.Radiobutton
+        self.RadioButton7 = tk.Radiobutton
+        self.RadioButton8 = tk.Radiobutton
+        self.RadioButton9 = tk.Radiobutton
+        self.RadioButton10 = tk.Radiobutton
+        self.RadioButton11 = tk.Radiobutton
+        self.RadioButton12 = tk.Radiobutton
+
+        self.StartButton = tk.Button
+        self.StopButton = tk.Button
+        self.PauseButton = tk.Button
+        self.QuitButton = tk.Button
+        self.TkPosition = '133x454+60+600'
+        self.setDaemon(True)
+        self.StatusLabel = tk.Label
+
+        self.global_timeout_label = tk.Label
+        self.hourly_breaks_label = tk.Label
+        self.break_duration_label = tk.Label
+        self.global_timeout_entry = tk.Entry
+        self.hourly_breaks_entry = tk.Entry
+        self.break_duration_entry = tk.Entry
+        self.global_timeout_use = tk.StringVar
+        self.hourly_breaks_use = tk.StringVar
+        self.break_duration_use = tk.StringVar
+
+
+
+        # self.TkPosition = config.returnEnemyPlayerOverlayPos()
+        #
+        self.start()
+
+    def run(self):
+        self.MiningOverlay = DiggingOverlay(game_base_class.MINING_LARGE)
+        self.root = tk.Tk()
+
+        self.rb_frame = tk.Frame(self.root)
+        self.rb_int = tk.IntVar(self.root, value=1)
+        self.RadioButtons = dict()
+        # var = tk.IntVar(value=1)
+        for i in range(1, 13):
+            self.RadioButtons[i] = tk.Radiobutton(self.rb_frame, text=self.RadioButtonNames[i - 1],
+                                                  variable=self.rb_int,
+                                                  value=i, command=self.radio_button_callback)
+            self.RadioButtons[i].grid(row=i, column=0, sticky='w')
+
+        self.parameter_frame = tk.Frame(self.root)
+        self.energy_use = tk.StringVar(self.root, value='2000')
+        self.spawn_use = tk.StringVar(self.root, value='25')
+        self.emitter_use = tk.StringVar(self.root, value='multi')
+
+        self.EnergyLabel = tk.Label(self.parameter_frame, text="Runs:", font=("Helvetica", 10, "bold"),
+                                    background="grey", width='6')
+        self.EnergyEntry = tk.Entry(self.parameter_frame, textvariable=self.energy_use, font=("Helvetica", 10, "bold"),
+                                    width='10')
+        self.SpawnLabel = tk.Label(self.parameter_frame, text="Spawn:", font=("Helvetica", 10, "bold"),
+                                   background="grey", width='6')
+        self.SpawnEntry = tk.Entry(self.parameter_frame, textvariable=self.spawn_use, font=("Helvetica", 10, "bold"),
+                                   width='10')
+        self.EmitterLabel = tk.Label(self.parameter_frame, text="Emitter:", font=("Helvetica", 10, "bold"),
+                                     background="grey", width='6')
+        self.Emitter_Box = ttk.Combobox(self.parameter_frame, textvariable=self.emitter_use,
+                                        font=("Helvetica", 8, "bold"),
+                                        width='9')
+        self.Emitter_Box['values'] = ('multi', 'main', 'mushroom', 'amulett', 'sword', 'staff', 'wand', 'ring')
+
+        self.EnergyLabel.grid(row=0, column=0, sticky='w')
+        self.EnergyEntry.grid(row=0, column=1)
+        self.SpawnLabel.grid(row=1, column=0, sticky='w')
+        self.SpawnEntry.grid(row=1, column=1)
+        self.EmitterLabel.grid(row=2, column=0, sticky='w')
+        self.Emitter_Box.grid(row=2, column=1)
+
+        self.ButtonFrame = tk.Frame(self.root)
+        self.StartButton = tk.Button(self.ButtonFrame, text="Start", command=self.start_button_callback, width='5')
+        self.StopButton = tk.Button(self.ButtonFrame, text="Stop", command=self.stop_button_callback, width='5',
+                                    state=tk.DISABLED)
+        self.PauseButton = tk.Button(self.ButtonFrame, text="Pause", command=self.pause_button_callback, width='5',
+                                     state=tk.DISABLED)
+        self.QuitButton = tk.Button(self.ButtonFrame, text="Quit", command=self.quit_button_callback, width='5',
+                                    state=tk.NORMAL)
+
+        self.StartButton.grid(row=0, column=0)
+        self.StopButton.grid(row=1, column=0)
+        self.PauseButton.grid(row=2, column=0)
+        self.QuitButton.grid(row=4, column=0)
+
+        self.StatusLabel = tk.Label(self.root, text="Nothing to see here", font=("Helvetica", 10, "bold"),
+                                    background="grey", anchor=tk.CENTER)
+
+        self.timing_frame = tk.Frame(self.root)
+
+        self.global_timeout_use = tk.StringVar(self.root, value='0')
+        self.hourly_breaks_use = tk.StringVar(self.root, value='0')
+        self.break_duration_use = tk.StringVar(self.root, value='1-3')
+
+        self.global_timeout_label = tk.Label(self.timing_frame, text="Stop after (h):", font=("Helvetica", 10, "bold"),
+                                    background="grey", width='12')
+        self.hourly_breaks_label = tk.Label(self.timing_frame, text="Breaks:", font=("Helvetica", 10, "bold"),
+                                    background="grey", width='12')
+        self.break_duration_label = tk.Label(self.timing_frame, text="Break time (m):", font=("Helvetica", 10, "bold"),
+                                    background="grey", width='12')
+        self.global_timeout_entry = tk.Entry(self.timing_frame, textvariable=self.global_timeout_use, font=("Helvetica", 10, "bold"),
+                                    width='3')
+        self.hourly_breaks_entry = tk.Entry(self.timing_frame, textvariable=self.hourly_breaks_use, font=("Helvetica", 10, "bold"),
+                                    width='3')
+        self.break_duration_entry = tk.Entry(self.timing_frame, textvariable=self.break_duration_use, font=("Helvetica", 10, "bold"),
+                                    width='3', state=tk.DISABLED)
+
+
+
+        self.global_timeout_label.grid(row=0, column=0, sticky='w', columnspan=2 )
+        self.global_timeout_entry.grid(row=0, column=3)
+        self.hourly_breaks_label.grid(row=1, column=0, sticky='w', columnspan=2)
+        self.hourly_breaks_entry.grid(row=1, column=3)
+        self.break_duration_label.grid(row=2, column=0, sticky='w', columnspan=2)
+        self.break_duration_entry.grid(row=2, column=3)
+
+
+
+        self.rb_frame.grid(row=0, column=0, sticky='w')
+        self.ButtonFrame.grid(row=0, column=1, sticky='w')
+        self.parameter_frame.grid(row=1, column=0, columnspan=2, sticky='w')
+        self.timing_frame.grid(row=2, column=0, columnspan=2, sticky='w')
+        self.StatusLabel.grid(row=3, column=0, columnspan=2)
+
+        # self.ClearButton.pack(side="top")
+        self.root.geometry(self.TkPosition)
+        self.root.overrideredirect(1)  # fenster ohne aussen rum :-)
+        # self.root.attributes('-alpha', 0.7)  # fenster transparent
+        self.root.attributes('-topmost', 1)  # fenster immer im vordergrund
+        # self.root.wm_attributes("-disabled", True)
+        # self.root.configure(background='black')
+        self.hide_mining_overlay()
+        self.root.mainloop()
+
+    def callback(self):
+        self.root.quit()
+
+    def destroy(self):
+        self.hide_mining_overlay()
+        del self.MiningOverlay
+        self.root.destroy()
+
+    def start_button_callback(self):
+        self.StartButton.configure(state=tk.DISABLED)
+        self.StopButton.configure(state=tk.NORMAL)
+        self.PauseButton.configure(state=tk.NORMAL)
+        self.QuitButton.configure(state=tk.DISABLED)
+        for i in range(1, 9):
+            tt = self.rb_int.get()
+            if self.rb_int.get() != i:
+                (self.RadioButtons[i]).configure(state=tk.DISABLED)
+        self.StatusLabel.configure(text='started')
+        self.run_mode = 'started'
+
+    def stop_button_callback(self):
+        self.StartButton.configure(state=tk.NORMAL)
+        self.StopButton.configure(state=tk.DISABLED)
+        self.PauseButton.configure(state=tk.DISABLED)
+        self.QuitButton.configure(state=tk.NORMAL)
+        for i in range(1, 9):
+            self.RadioButtons[i].configure(state=tk.NORMAL)
+        self.run_mode = 'stopped'
+
+    def pause_button_callback(self):
+        self.StartButton.configure(state=tk.NORMAL)
+        self.StopButton.configure(state=tk.NORMAL)
+        self.PauseButton.configure(state=tk.DISABLED)
+        self.QuitButton.configure(state=tk.DISABLED)
+        self.run_mode = 'paused'
+
+    def quit_button_callback(self):
+        self.run_mode = 'quit'
+
+    def radio_button_callback(self):
+        if self.rb_int.get() == 1:
+            self.EnergyEntry.configure(state=tk.NORMAL)
+            self.energy_use.set('2000')
+            self.SpawnEntry.configure(state=tk.NORMAL)
+            self.spawn_use.set('25')
+            self.Emitter_Box.configure(state=tk.NORMAL)
+            self.Emitter_Box.configure(values=('multi', 'main', 'mushroom', 'amulett', 'sword', 'staff', 'wand', 'ring'))
+            self.EmitterLabel.configure(text="Emitter:")
+            self.SpawnLabel.configure(text="Spawn:")
+            self.EnergyLabel.configure(text="Runs:")
+            self.emitter_use.set('multi')
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 2:
+            self.EnergyEntry.configure(state=tk.DISABLED)
+            self.energy_use.set('')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.NORMAL)
+            self.Emitter_Box.configure(values=('rainbow', 'bigbomb', 'rocket', 'bomb'))
+            self.emitter_use.set('rainbow')
+            self.EmitterLabel.configure(text="Strat:")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="")
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 3:
+            self.EnergyEntry.configure(state=tk.DISABLED)
+            self.energy_use.set('')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.DISABLED)
+            self.emitter_use.set('')
+            self.EmitterLabel.configure(text="")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="")
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 4:
+            self.EnergyEntry.configure(state=tk.DISABLED)
+            self.energy_use.set('')
+            self.SpawnEntry.configure(state=tk.NORMAL)
+            self.spawn_use.set('100')
+            self.Emitter_Box.configure(state=tk.DISABLED)
+            self.emitter_use.set('')
+            self.EmitterLabel.configure(text="")
+            self.SpawnLabel.configure(text="Spawn:")
+            self.EnergyLabel.configure(text="")
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 5:
+            self.EnergyEntry.configure(state=tk.NORMAL)
+            self.energy_use.set('100')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.NORMAL)
+            self.Emitter_Box.configure(values=('m25x1', 'm10x2', 'm5x3', 'simple', 'm1x5_T', 'm1x5_X', 'house'))
+            self.emitter_use.set('simple')
+            self.EmitterLabel.configure(text="Mode:")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="Runs:")
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 6:
+            self.EnergyEntry.configure(state=tk.NORMAL)
+            self.energy_use.set('2')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.DISABLED)
+            self.emitter_use.set('')
+            self.EmitterLabel.configure(text="")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="Runs:")
+            self.show_mining_overlay()
+        elif self.rb_int.get() == 7:
+            self.EnergyEntry.configure(state=tk.DISABLED)
+            self.energy_use.set('')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.DISABLED)
+            self.emitter_use.set('')
+            self.EmitterLabel.configure(text="")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="")
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 8:
+            self.EnergyEntry.configure(state=tk.DISABLED)
+            self.energy_use.set('')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.DISABLED)
+            self.emitter_use.set('')
+            self.EmitterLabel.configure(text="")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="")
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 9:
+            self.EnergyEntry.configure(state=tk.DISABLED)
+            self.energy_use.set('')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.DISABLED)
+            self.emitter_use.set('')
+            self.EmitterLabel.configure(text="")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="")
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 10:
+            self.EnergyEntry.configure(state=tk.DISABLED)
+            self.energy_use.set('')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.DISABLED)
+            self.emitter_use.set('')
+            self.EmitterLabel.configure(text="")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="")
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 11:
+            self.EnergyEntry.configure(state=tk.DISABLED)
+            self.energy_use.set('')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.DISABLED)
+            self.emitter_use.set('')
+            self.EmitterLabel.configure(text="")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="")
+            self.hide_mining_overlay()
+        elif self.rb_int.get() == 12:
+            self.EnergyEntry.configure(state=tk.DISABLED)
+            self.energy_use.set('')
+            self.SpawnEntry.configure(state=tk.DISABLED)
+            self.spawn_use.set('')
+            self.Emitter_Box.configure(state=tk.DISABLED)
+            self.emitter_use.set('')
+            self.EmitterLabel.configure(text="")
+            self.SpawnLabel.configure(text="")
+            self.EnergyLabel.configure(text="")
+            self.hide_mining_overlay()
+    def get_run_mode(self):
+        return self.run_mode
+
+    def update_status_label(self, msg):
+        self.StatusLabel.configure(text=msg)
+
+    def hide_mining_overlay(self):
+        self.MiningOverlay.hide_window()
+
+    def show_mining_overlay(self):
+        self.MiningOverlay.show_window()
+
+    def get_strategy_value_as_int(self):
+        if self.emitter_use.get() == "rainbow":
+            return 11
+        elif self.emitter_use.get() == "bigbomb":
+            return 9
+        elif self.emitter_use.get() == "rocket":
+            return 7
+        elif self.emitter_use.get() == "bomb":
+            return 5
+        else:
+            return 11

config_file.py

@@ -59,9 +59,12 @@ class UserConfigs:
         else:
             pass
 
-    def returnDiggingWindowPos2(self):
+    def returnDiggingWindowPos2(self, large=True):
         if self.user == self.THALOUSER:
-            return [1440, 1150, 570, 22]
+            if large:
+                return [1440, 1150, 570, 22]
+            else:
+                return [1440, 210, 560, 700]
         elif self.user == self.ADWAUSER:
             return [740, 450, 1625, 985]
         elif self.user == self.EDDIEUSER:

craft.py

@@ -0,0 +1,332 @@
+import cv2 as cv
+from utils import get_click_point, dig_point, check_for_craft_ok_button, check_for_craft_button
+import pydirectinput
+from config_file import UserConfigs
+from window_capture import WindowCapture
+from vision import Vision
+from game_base_class import GameBase
+
+MODE25X1 = "m25x1"
+MODE10X2 = "m10x2"
+MODE5X3 = "m5x3"
+MODE_SIMPLE_STACK = "simple"
+MODE1X5_T = "m1x5_T"
+MODE1X5_X = "m1x5_X"
+MODE_HOUSE = "house"
+
+
+class Craft(GameBase):
+
+    def __init__(self, overlay):
+        super().__init__(overlay)
+
+        self.mode = str(overlay.emitter_use.get())
+        self.run_target = int(overlay.energy_use.get())
+
+        self.run_counter = 0
+        self.dimension = 172
+
+    def assess_playfield_and_make_move(self):
+        if self.run_counter >= self.run_target:
+            self.run_counter = 0
+            self.overlay.run_mode = 'finished'
+            return
+
+        ab1 = [420, 1180, 142, 142]
+        ab2 = [562, 1180, 142, 142]
+        ab3 = [704, 1180, 142, 142]
+        ab4 = [846, 1180, 142, 142]
+        ab5 = [986, 1180, 142, 142]
+        ab6 = [1128, 1180, 142, 142]
+        ab10 = [1698, 1180, 142, 142]
+
+        if self.mode == MODE25X1:
+            self.click_square_center(ab1)
+
+            # grid 770 1630  160 1020   172 o
+            self.dimension = 172
+            for i in range(0, 5, 1):
+                for e in range(0, 5, 1):
+                    self.click_square_center(
+                        [770 + (i * self.dimension), 160 + (e * self.dimension), self.dimension, self.dimension])
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+
+            self.click_craft_button()
+
+            for i in range(0, 5, 1):
+                for e in range(0, 5, 1):
+                    self.collect_grid_reverse_click(
+                        [770 + (i * self.dimension), 160 + (e * self.dimension), self.dimension, self.dimension])
+                    self.run_counter = self.run_counter + 1
+                    self.overlay.update_status_label(self.mode + ": " + str(self.run_target - self.run_counter))
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+            self.click_square_center(ab10)
+        elif self.mode == MODE10X2:
+            for r in range(0, 2, 1):
+                # grid 770 1630  160 1020   172
+
+                if r == 0:
+                    self.click_square_center(ab1)
+                    start = 0
+                    target = 3
+                else:
+                    self.click_square_center(ab2)
+                    start = 1
+                    target = 4
+
+                for i in range(start, target, 2):
+                    for e in range(0, 5, 1):
+                        self.click_square_center(
+                            [770 + (i * self.dimension), 160 + (e * self.dimension), self.dimension,
+                             self.dimension])
+                        if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                            return
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+
+            self.click_craft_button()
+
+            for i in range(0, 4, 2):
+                for e in range(0, 5, 1):
+                    self.collect_grid_reverse_click(
+                        [770 + (i * self.dimension), 160 + (e * self.dimension), self.dimension, self.dimension])
+                    self.run_counter = self.run_counter + 1
+                    self.overlay.update_status_label(self.mode + ": " + str(self.run_target - self.run_counter))
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+            self.click_square_center(ab10)
+        elif self.mode == MODE5X3:
+            for r in range(0, 3, 1):
+                # grid 770 1630  160 1020   172oo
+                self.dimension = 172
+                if r == 0:
+                    self.click_square_center(ab1)
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                    start = 0
+                    target = 1
+                elif r == 1:
+                    self.click_square_center(ab2)
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                    start = 1
+                    target = 2
+                else:
+                    self.click_square_center(ab3)
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                    start = 2
+                    target = 3
+
+                for i in range(start, target, 1):
+                    for e in range(0, 5, 1):
+                        self.click_square_center(
+                            [770 + (i * self.dimension), 160 + (e * self.dimension), self.dimension,
+                             self.dimension])
+                        if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                            return
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+
+            self.click_craft_button()
+
+            for i in range(0, 1, 1):
+                if self.overlay.run_mode == 'stopped':
+                    return
+                for e in range(0, 5, 1):
+                    self.collect_grid_reverse_click(
+                        [770 + (i * self.dimension), 160 + (e * self.dimension), self.dimension, self.dimension])
+                    self.run_counter = self.run_counter + 1
+                    self.overlay.update_status_label(self.mode + ": " + str(self.run_target - self.run_counter))
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+            self.click_square_center(ab10)
+        elif self.mode == MODE1X5_T:
+            tps = [ab1,
+                   [770 + (0 * self.dimension), 160 + (2 * self.dimension), self.dimension, self.dimension],
+                   [770 + (1 * self.dimension), 160 + (2 * self.dimension), self.dimension, self.dimension],
+                   ab2,
+                   [770 + (2 * self.dimension), 160 + (1 * self.dimension), self.dimension, self.dimension],
+                   [770 + (2 * self.dimension), 160 + (2 * self.dimension), self.dimension, self.dimension],
+                   [770 + (2 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension]]
+
+            result_tp = [770 + (0 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension]
+
+            for tp in tps:
+                self.click_square_center(tp)
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+
+            self.click_craft_button()
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+            self.click_square_center(result_tp)
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+            self.click_square_center(ab10)
+
+            self.run_counter = self.run_counter + 1
+            self.overlay.update_status_label(self.mode + ": " + str(self.run_target - self.run_counter))
+
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+        elif self.mode == MODE1X5_X:
+            tps = [ab1,
+                   [770 + (0 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension],
+                   [770 + (1 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension],
+                   [770 + (2 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension],
+                   [770 + (1 * self.dimension), 160 + (4 * self.dimension), self.dimension, self.dimension],
+                   [770 + (1 * self.dimension), 160 + (2 * self.dimension), self.dimension, self.dimension]]
+
+            result_tp = [770 + (0 * self.dimension), 160 + (4 * self.dimension), self.dimension, self.dimension]
+
+            for tp in tps:
+                self.click_square_center(tp)
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+
+            self.click_craft_button()
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+            self.click_square_center(result_tp)
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+            self.click_square_center(ab10)
+
+            self.run_counter = self.run_counter + 1
+            self.overlay.update_status_label(self.mode + ": " + str(self.run_target - self.run_counter))
+
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+        elif self.mode == MODE_HOUSE:
+            cements = [[770 + (0 * self.dimension), 160 + (4 * self.dimension), self.dimension, self.dimension],
+                       [770 + (1 * self.dimension), 160 + (4 * self.dimension), self.dimension, self.dimension],
+                       [770 + (2 * self.dimension), 160 + (4 * self.dimension), self.dimension, self.dimension],
+                       [770 + (3 * self.dimension), 160 + (4 * self.dimension), self.dimension, self.dimension],
+                       [770 + (4 * self.dimension), 160 + (4 * self.dimension), self.dimension, self.dimension]]
+
+            bricks = [[770 + (0 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension],
+                      [770 + (1 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension],
+                      [770 + (3 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension],
+                      [770 + (4 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension],
+                      [770 + (0 * self.dimension), 160 + (2 * self.dimension), self.dimension, self.dimension],
+                      [770 + (2 * self.dimension), 160 + (2 * self.dimension), self.dimension, self.dimension],
+                      [770 + (4 * self.dimension), 160 + (2 * self.dimension), self.dimension, self.dimension]]
+
+            boards = [[770 + (2 * self.dimension), 160 + (3 * self.dimension), self.dimension, self.dimension],
+                      [770 + (0 * self.dimension), 160 + (1 * self.dimension), self.dimension, self.dimension],
+                      [770 + (1 * self.dimension), 160 + (1 * self.dimension), self.dimension, self.dimension],
+                      [770 + (2 * self.dimension), 160 + (1 * self.dimension), self.dimension, self.dimension],
+                      [770 + (3 * self.dimension), 160 + (1 * self.dimension), self.dimension, self.dimension],
+                      [770 + (4 * self.dimension), 160 + (1 * self.dimension), self.dimension, self.dimension],
+                      [770 + (2 * self.dimension), 160 + (0 * self.dimension), self.dimension, self.dimension]]
+
+            glasses = [[770 + (1 * self.dimension), 160 + (2 * self.dimension), self.dimension, self.dimension],
+                       [770 + (3 * self.dimension), 160 + (2 * self.dimension), self.dimension, self.dimension]]
+
+            tp_hammer = [770 + (1 * self.dimension), 160 + (0 * self.dimension), self.dimension, self.dimension]
+            tp_nails = [770 + (3 * self.dimension), 160 + (0 * self.dimension), self.dimension, self.dimension]
+            tp_result = [770 + (0 * self.dimension), 160 + (4 * self.dimension), self.dimension, self.dimension]
+
+            self.click_square_center(ab1)
+
+            for cement in cements:
+                self.click_square_center(cement)
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+
+            self.click_square_center(ab2)
+
+            for brick in bricks:
+                self.click_square_center(brick)
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+
+            self.click_square_center(ab3)
+
+            for board in boards:
+                self.click_square_center(board)
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+
+            self.click_square_center(ab4)
+
+            for glass in glasses:
+                self.click_square_center(glass)
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+
+            self.click_square_center(ab5)
+            self.click_square_center(tp_hammer)
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+
+            self.click_square_center(ab6)
+            self.click_square_center(tp_nails)
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+
+            self.click_craft_button()
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+
+            self.click_square_center(tp_result)
+            self.click_square_center(ab10)
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+
+            self.run_counter = self.run_counter + 1
+            self.overlay.update_status_label(self.mode + ": " + str(self.run_target - self.run_counter))
+
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+        elif self.mode == MODE_SIMPLE_STACK:
+            # initialize the StunWindowCapture class
+            capture_config = UserConfigs()
+            # capture_window = WindowCapture(None, "screen_conf", capture_config)
+
+            capture_window2 = WindowCapture(None, "bla", capture_config)
+
+            # initialize the StunVision class
+            vision_stun = Vision()
+            # dig_overlay = DiggingOverlay(config)
+            check_for_craft_button(capture_window2, vision_stun)
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+            check_for_craft_ok_button(capture_window2, vision_stun)
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+            self.run_counter = self.run_counter + 1
+            self.overlay.update_status_label(self.mode + ": " + str(self.run_target - self.run_counter))
+            # check_for_ok_button(capture_window, vision_stun, capture_config)
+
+    def collect_grid_reverse_click(self, square):
+        pydirectinput.moveTo(get_click_point(square)[0], get_click_point(square)[1])
+        cv.waitKey(50)
+        pydirectinput.mouseUp()
+        cv.waitKey(50)
+        pydirectinput.mouseDown()
+        cv.waitKey(100)
+
+    def click_craft_button(self):
+        dig_point(1910, 330, 100)
+        cv.waitKey(1500)
+
+    def click_square_center(self, square):
+        cp = get_click_point(square)
+        dig_point(cp[0], cp[1], 100)
+        cv.waitKey(100)

create_mask_from_png.py

@@ -10,7 +10,7 @@ from config_file import UserConfigs
 # load the original input image and display it to our screen
 
 #filename = "equip/chests/chest_23_32"
-path = "equip/wands/"
+path = "flappy/"
 os.chdir(path)
 
 for entry in os.listdir():

crops.py

@@ -0,0 +1,394 @@
+import random
+import cv2 as cv
+import numpy as np
+import pydirectinput
+from utils import mse
+from utils import get_click_point
+from hsvfilter import HsvFilter
+from game_base_class import GameBase
+
+GREEN = 1
+YELLOW = 2
+RED = 3
+BLUE = 4
+PURPLE = 5
+RAINBOW = 6
+BIGBOMB = 7
+BOMB = 8
+ARROW_DOWN = 9
+ARROW_RIGHT = 10
+ROCK_1 = 11
+ROCK_2 = 12
+ROCK_3 = 13
+BURGER = 14
+PAB1 = 15
+GOLDBAR = 16
+MAGINENT = 21
+CHEMTRANT = 22
+TENESENT = 23
+CIBUTRANT = 24
+ARTISENT = 25
+
+STATUS_FOUND_CONTINUATION = "1"
+STATUS_FOUND_DEADEND = "2"
+STATUS_FOUND_ENDING = "3"
+
+RAINBOW_STRATEGY = 11
+BIGBOMB_STRATEGY = 9
+ROCKET_STRATEGY = 7
+BOMB_STRATEGY = 5
+
+
+class Crops(GameBase):
+
+    def __init__(self, overlay):
+        super().__init__(overlay)
+
+        self.screenshot = []
+
+        self.needles = {}
+        self.hsh_needles = {}
+
+        self.colors.append(PURPLE)
+
+        self.current_strategy = overlay.get_strategy_value_as_int()
+
+        self.fill_data_coordinates()
+
+        self.set_color_order((GREEN, YELLOW, RED, BLUE, PURPLE))
+
+    def set_color_order(self, order):
+        self.needles.clear()
+        self.needles = {order[0]: cv.imread("crop/green.jpg", cv.IMREAD_COLOR),
+                        order[1]: cv.imread("crop/yellow.jpg", cv.IMREAD_COLOR),
+                        order[2]: cv.imread("crop/red.jpg", cv.IMREAD_COLOR),
+                        order[3]: cv.imread("crop/blue.jpg", cv.IMREAD_COLOR),
+                        order[4]: cv.imread("crop/purple.jpg", cv.IMREAD_COLOR),
+
+                        RAINBOW: cv.imread("crop/rainbow.jpg", cv.IMREAD_COLOR),
+                        BIGBOMB: cv.imread("crop/bigbomb.jpg", cv.IMREAD_COLOR),
+                        BOMB: cv.imread("crop/bomb.jpg", cv.IMREAD_COLOR),
+                        ARROW_DOWN: cv.imread("crop/arrow_down.jpg", cv.IMREAD_COLOR),
+                        ARROW_RIGHT: cv.imread("crop/arrow_right.jpg", cv.IMREAD_COLOR),
+
+                        MAGINENT: cv.imread("crop/maginent.jpg", cv.IMREAD_COLOR),
+                        CHEMTRANT: cv.imread("crop/chemtrant.jpg", cv.IMREAD_COLOR),
+                        TENESENT: cv.imread("crop/tenesent.jpg", cv.IMREAD_COLOR),
+                        CIBUTRANT: cv.imread("crop/cibutrant.jpg", cv.IMREAD_COLOR),
+                        ARTISENT: cv.imread("crop/artisent.jpg", cv.IMREAD_COLOR)
+                        }
+        self.hsh_needles.clear()
+        self.hsh_needles = {order[0]: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            order[1]: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            order[2]: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            order[3]: HsvFilter(60, 40, 0, 115, 255, 255, 0, 0, 0, 0),
+                            order[4]: HsvFilter(120, 45, 0, 170, 255, 255, 0, 0, 0, 0),
+
+                            RAINBOW: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            BIGBOMB: HsvFilter(60, 40, 0, 179, 129, 129, 0, 0, 0, 0),
+                            BOMB: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            ARROW_DOWN: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            ARROW_RIGHT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+
+                            MAGINENT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            CHEMTRANT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            TENESENT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            CIBUTRANT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0),
+                            ARTISENT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0)
+                            }
+
+    def assess_playfield_and_make_move(self):
+
+        new_observation, new_screenshot = self.get_current_board_state()
+
+        # wrong movement detection
+        # last board state is same as actual
+        if mse(new_observation, self.observation) == 0.0:
+            # no movement detected -> blow explosives or reset
+
+            self.reset_counter += 1
+            if self.reset_counter == 1:
+                pass
+            elif self.reset_counter == 2:
+                if self.detonate_explosive_when_stuck(new_observation):
+                    new_observation, new_screenshot = self.get_current_board_state()
+                    if mse(new_observation, self.observation) != 0.0:
+                        self.reset_counter = 0
+                return
+            elif self.reset_counter >= 3:
+                screenshot = self.capture_window.get_screenshot()
+                if self.check_for_button_and_execute(screenshot, self.reset_board):
+                    cv.waitKey(500)
+                screenshot = self.capture_window.get_screenshot()
+                if self.check_for_button_and_execute(screenshot, self.reset_confirm):
+                    cv.waitKey(500)
+
+                color_list = [PURPLE, BLUE, RED, YELLOW, GREEN]
+                random.shuffle(color_list)
+                self.set_color_order(color_list)
+                self.current_strategy = random.choice([RAINBOW_STRATEGY, BIGBOMB_STRATEGY,
+                                                       ROCKET_STRATEGY, BOMB_STRATEGY])
+                self.reset_counter = 0
+                return
+            else:
+                return
+
+        self.find_patterns_and_valid_moves(new_observation)
+        self.observation = new_observation
+        return new_observation
+
+    def get_current_board_state(self):
+
+        # get an updated image of the game
+        screenshot = self.capture_window.get_screenshot()
+        # screenshot = cv.imread("playfield.jpg")
+        screenshot = screenshot[190:1230, 260:2090]
+        self.screenshot = screenshot
+        # gray = cv.cvtColor(screenshot, cv.COLOR_BGR2GRAY)
+        # thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
+        offset_left = 230
+        offset_down = 58
+        if self.check_for_button_and_execute(screenshot, self.next_level, offset_left, offset_down):
+            self.set_color_order((GREEN, YELLOW, RED, BLUE, PURPLE))
+            self.current_strategy = RAINBOW_STRATEGY
+            cv.waitKey(500)
+            screenshot = self.capture_window.get_screenshot()
+            screenshot = screenshot[190:1230, 260:2090]
+        if self.check_for_button_and_execute(screenshot, self.next_level_x, offset_left, offset_down):
+            cv.waitKey(500)
+            screenshot = self.capture_window.get_screenshot()
+            screenshot = screenshot[190:1230, 260:2090]
+
+        # cv.imshow("screenshot", screenshot)
+        # cv.waitKey(150)
+        # continue
+        data_coords = np.zeros((8, 14), dtype=object)
+        # field = Pickaxe_Field()
+
+        for needle_key in self.needles.keys():
+            # gray_needle = cv.cvtColor(self.needles[needle_key], cv.COLOR_BGR2GRAY)
+            # thresh_needle = cv.threshold(gray_needle, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
+            processed_screenshot = self.vision_stun.apply_hsv_filter(screenshot, self.hsh_needles[needle_key])
+            processed_needle = self.vision_stun.apply_hsv_filter(self.needles[needle_key], self.hsh_needles[needle_key])
+            rectangles = self.vision_stun.find(processed_screenshot, processed_needle, 0.70, 56)
+            # rectangles = self.vision_stun.find(screenshot, self.needles[needle_key], 0.70, 56)
+            if len(rectangles) == 0:
+                continue
+            points = self.vision_stun.get_click_points(rectangles)
+
+            for point in points:
+                x, y = self.point_in_rect(point)
+                if x is not None and y is not None:
+                    data_coords[x][y] = int(needle_key)
+                    # self.change_value(x, y, int(needle_key))
+                    # print(field.data_value_grid)
+                    # cv.circle(screenshot, points[0], 7, (0, 255, 0), -1)
+                    # output_image = vision_stun.draw_rectangles(screenshot, rectangles)
+                    # cv.imshow("output_image", output_image)
+                    # cv.waitKey(150)
+
+        score_map = np.zeros((8, 14), dtype=object)
+        for x in range(0, 8, 1):
+            for y in range(0, 14, 1):
+                score_map[x, y] = self.score_for_attached_same_color_all_directions(data_coords, x, y)
+                #cv.putText(screenshot, str(score_map[x, y]),
+                #           self.get_click_point(self.data_coordinates[x, y]), cv.FONT_HERSHEY_SIMPLEX,
+                #           1, (0, 0, 0), 3, 2)
+        #cv.imwrite('screenshot_scored.jpg', screenshot)
+
+        return data_coords, screenshot
+
+    def find_patterns_and_valid_moves(self, state):
+        # score_map = np.zeros((8, 14), dtype=object)
+        for x in range(0, 8, 1):
+            for y in range(0, 14, 1):
+                self.data_score_map[x, y] = self.score_for_attached_same_color_all_directions(state, x, y)
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+
+        full_moves = []
+        reserve_moves = []
+        for x in range(0, 8, 1):
+            for y in range(0, 14, 1):
+                if self.check_explosives(state, x, y):
+                    return
+                if self.data_score_map[x, y] >= 4:
+                    path_option = [[x, y]]
+                    recursion_reminder = [[x, y]]
+                    result = self.find_next_same_color_all_directions_recursion(state, x, y, path_option,
+                                                                                recursion_reminder, True)
+                    if result == STATUS_FOUND_ENDING:
+                        path_option.append([x, y])
+                    if len(path_option) >= 5:
+                        full_moves.append((state[x, y], path_option))
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                if self.data_score_map[x, y] >= 1:
+                    path_option = [[x, y]]
+                    self.find_next_same_color_all_directions_recursion2(state, x, y, path_option)
+                    if len(path_option) >= 3:
+                        reserve_moves.append((state[x, y], path_option))
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+        # print(self.data_score_map)
+
+        # screenshot = cv.imread("screenshot_scored.jpg")
+        full_dic = self.convert_moves_to_dic_by_color(full_moves)
+        res_dic = self.convert_moves_to_dic_by_color(reserve_moves)
+
+        full_moves.sort(key=len, reverse=True)
+        reserve_moves.sort(key=len, reverse=True)
+
+        if len(full_dic) >= 1:
+            for key in sorted(full_dic):
+                if len(full_dic[key]) >= self.current_strategy:
+                    #self.print_move(full_dic[key])
+                    self.execute_move(full_dic[key])
+                    return
+        if len(reserve_moves) >= 1:
+            for key in sorted(res_dic):
+                #self.print_move(res_dic[key])
+                self.execute_move(res_dic[key])
+                break
+
+    @staticmethod
+    def convert_moves_to_dic_by_color(reserve_moves):
+        dic = {}
+        for color, move in reserve_moves:
+            if color in dic:
+                if len(move) > len(dic[color]):
+                    dic[color] = move
+            else:
+                dic[color] = move
+        return dic
+
+    def print_move(self, move):
+        mp = []
+        for point in move:
+            cp = self.get_click_point(self.data_coordinates[point[0], point[1]])
+            mp.append(cp)
+        cv.polylines(self.screenshot,
+                     [np.array(mp)],
+                     isClosed=False,
+                     color=(0, 255, 0),
+                     thickness=3)
+
+        cv.imwrite('screenshot_pathed.jpg', self.screenshot)
+
+    def execute_move(self, move):
+        offset_left = 230
+        offset_down = 58
+
+        first = True
+        for cords in move:
+            square = self.data_coordinates[cords[0], cords[1]]
+            pydirectinput.moveTo(get_click_point(square)[0] + offset_left, get_click_point(square)[1] + offset_down)
+            cv.waitKey(50)
+            if first:
+                pydirectinput.mouseDown()
+                cv.waitKey(100)
+                first = False
+        pydirectinput.mouseUp()
+        cv.waitKey(50)
+
+    @staticmethod
+    def get_directions_array(current_x, current_y):
+        left_x = current_x
+        left_y = current_y - 1
+
+        right_x = current_x
+        right_y = current_y + 1
+
+        upper_x = current_x - 1
+        upper_y = current_y
+
+        lower_x = current_x + 1
+        lower_y = current_y
+
+        lower_left_x = current_x + 1
+        lower_left_y = current_y - 1
+
+        lower_right_x = current_x + 1
+        lower_right_y = current_y + 1
+
+        upper_left_x = current_x - 1
+        upper_left_y = current_y - 1
+
+        upper_right_x = current_x - 1
+        upper_right_y = current_y + 1
+
+        directions = [[left_x, left_y], [lower_left_x, lower_left_y], [lower_x, lower_y],
+                      [lower_right_x, lower_right_y], [right_x, right_y], [upper_right_x, upper_right_y],
+                      [upper_x, upper_y], [upper_left_x, upper_left_y]]
+
+        return directions
+
+    def find_next_same_color_all_directions_recursion(self, state, current_x, current_y, path_store, recursion_reminder,
+                                                      look_for_ending):
+        directions = self.get_directions_array(current_x, current_y)
+        color = state[current_x, current_y]
+
+        for direction in directions:
+            if self.is_direction_in_bounce_and_same_color(state, direction, color) == 1:
+                if (self.data_score_map[direction[0], direction[1]] >= 2) and (direction not in recursion_reminder):
+                    recursion_reminder.append(direction)
+                    result = self.find_next_same_color_all_directions_recursion(state, direction[0], direction[1],
+                                                                                path_store, recursion_reminder,
+                                                                                look_for_ending)
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        break
+                    if result == STATUS_FOUND_CONTINUATION:
+                        path_store.append(direction)
+                        return STATUS_FOUND_CONTINUATION
+                    elif result == STATUS_FOUND_DEADEND:
+                        if look_for_ending:
+                            continue
+                        else:
+                            path_store.append(direction)
+                            return STATUS_FOUND_DEADEND
+                    elif result == STATUS_FOUND_ENDING:
+                        path_store.append(direction)
+                        return STATUS_FOUND_ENDING
+
+        if look_for_ending:
+            for direction in directions:
+                if direction == path_store[0]:
+                    # path_store.append(direction)
+                    return STATUS_FOUND_ENDING
+
+        return STATUS_FOUND_DEADEND
+
+    def find_next_same_color_all_directions_recursion2(self, state, current_x, current_y, path_store):
+        directions = self.get_directions_array(current_x, current_y)
+        color = state[current_x, current_y]
+
+        for direction in directions:
+            if self.is_direction_in_bounce_and_same_color(state, direction, color) == 1:
+                if (self.data_score_map[direction[0], direction[1]] >= 1) and (direction not in path_store):
+                    path_store.append(direction)
+                    result = self.find_next_same_color_all_directions_recursion2(state, direction[0], direction[1],
+                                                                                 path_store)
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        break
+                    if result == STATUS_FOUND_DEADEND:
+                        return STATUS_FOUND_DEADEND
+
+        return STATUS_FOUND_DEADEND
+
+    def score_for_attached_same_color_all_directions(self, state, current_x, current_y):
+        directions = self.get_directions_array(current_x, current_y)
+
+        score = 0
+        color = state[current_x, current_y]
+        if color not in self.colors:
+            return score
+        for direction in directions:
+            score = score + self.is_direction_in_bounce_and_same_color(state, direction, color)
+
+        return score

digging_main2.py

@@ -1,202 +0,0 @@
-import sys
-
-from config_file import UserConfigs
-import keyboard
-import cv2 as cv
-from utils import dig_point, check_for_ok_button
-from window_capture import WindowCapture
-from vision import Vision
-from dig_overlay import DiggingOverlay
-
-
-def run():
-    # initialize the user-class
-    config = UserConfigs()
-    # initialize the StunWindowCapture class
-    capture_config = UserConfigs()
-    capture_window = WindowCapture(None, "screen_conf", capture_config)
-
-    # initialize the StunVision class
-    vision_stun = Vision()
-    dig_overlay = DiggingOverlay(config)
-
-    pause = True
-    level = 1
-
-    width = 32
-    depth = 24
-    plot_size = 45
-    DIG_TIME = 100
-
-    runcounter = 2
-
-    if runcounter == 2:
-        double_dig = True
-    else:
-        double_dig = False
-
-    while runcounter != 0:
-        if double_dig and runcounter == 1:
-            dig_point(290, 100, 200)
-            level = 1
-            plot_size = 45
-            DIG_TIME = 100
-            cv.waitKey(2000)
-        runcounter = runcounter - 1
-
-        while True:
-            if keyboard.is_pressed('p') == True:
-                pause = True
-                print('q pressed')
-            elif keyboard.is_pressed('o') == True:
-                pause = False
-                print('o pressed')
-            if pause:
-                # cv.waitKey(500)
-                dig_overlay.show_window()
-                print("pausing")
-                continue
-            dig_overlay.hide_window()
-
-            if level >= 28:
-                break
-            if level == 23:
-                DIG_TIME = 800
-            if level == 26:
-                DIG_TIME = 1800
-            if level <= 10:
-                plot_size = plot_size - 1
-            elif level % 2 == 0:
-                plot_size = plot_size - 1
-
-            p1 = int((config.returnDiggingWindowPos2()[0] / 2) + config.returnDiggingWindowPos2()[2])
-            p2 = int((config.returnDiggingWindowPos2()[1] / 2) + config.returnDiggingWindowPos2()[3])
-
-            # start 705 , 564 -> click
-            # move L D -> click
-            # move U , U , R, R , D , D , L , L
-            # move L D
-            # move U , U , U , U , R, R , R, R, D, D, D, D, L, L, L , L
-            dig_point(p1, p2, DIG_TIME)
-            # cv.circle(screenshot, (p1, p2), 7, (0, 255, 0), -1)
-            i = 0
-            for e in range(2, width, 2):
-                i = i + 1
-
-                tp1 = p1 - (i * plot_size)
-                tp2 = p2 + (i * plot_size)
-                for f in range(0, e, 1):
-                    # up click
-                    tp2 = tp2 - plot_size
-                    if tp2 >= config.returnDiggingWindowPos2()[1] + (plot_size / 2):
-                        continue
-                    if tp2 <= config.returnDiggingWindowPos2()[3] + (plot_size / 2):
-                        continue
-                    '''
-                    x = int(tp1 - (plot_size / 2))
-                    y = int(tp2 - ((e * plot_size) - (plot_size / 2)))
-                    w = plot_size
-                    h = plot_size * e
-    
-                    capture_win_lanes = WindowCapture(None, "lanes", None, (w, h, x+w, y+h))
-                    screenshot = capture_win_lanes.get_screenshot()
-                    needlew = cv.imread("test1.jpg", cv.IMREAD_UNCHANGED)
-                    res = vision_stun.find(needlew, screenshot, 0.9, 1)
-                    if len(res) >= 1:
-                        break
-                    #vision_stun.draw_rectangles(needlew, res)
-                    #cv.imshow("screenshot", needlew)
-                    #cv.waitKey(150)
-    
-    
-                    # ul[0], ul[1], plot_size, plotsize*e
-    
-                    # ll -> tp1 - plot/2 ooooooooooo
-                    #    -> tp2 + plot/2
-                    # ul -> tp1 - plot/2
-                    #    -> tp2 - e*plot - plot/2
-                    # lr -> tp1 + plot/2
-                    #    -> tp2 - plot/2
-                    # ur -> tp1 + plot/2
-                    #    -> tp2 - e*plot - plot/2
-                    '''
-                    dig_point(tp1, tp2, DIG_TIME)
-                    # cv.circle(screenshot, (tp1, tp2), 7, (255, 0, 255), -1)
-                    # cv.imshow("screenshot", screenshot)
-                    # cv.waitKey(150)
-                    check_for_ok_button(capture_window, vision_stun, capture_config)
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-
-                tp1 = p1 - (i * plot_size)
-                tp2 = p2 - (i * plot_size)
-                for g in range(0, e, 1):
-                    # right click
-                    tp1 = tp1 + plot_size
-                    if tp2 <= config.returnDiggingWindowPos2()[3] + (plot_size / 2):
-                        continue
-
-                    # ll -> tp1 - plot/2
-                    #    -> tp2 + plot/2
-                    # ul -> tp1 - plot/2
-                    #    -> tp2 - plot/2
-                    # lr -> tp1 + e*plot + plot/2
-                    #    -> tp2 + plot/2
-                    # ur -> tp1 + e*plot + plot/2
-                    #    -> tp2 - plot/2
-
-                    dig_point(tp1, tp2, DIG_TIME)
-                    # cv.circle(screenshot, (tp1, tp2), 7, (127, 0, 255), -1)
-                    # cv.imshow("screenshot", screenshot)
-                    # cv.waitKey(150)
-                    check_for_ok_button(capture_window, vision_stun, capture_config)
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-
-                tp1 = p1 + (i * plot_size)
-                tp2 = p2 - (i * plot_size)
-                for r in range(0, e, 1):
-                    # down click
-                    tp2 = tp2 + plot_size
-                    if tp2 >= config.returnDiggingWindowPos2()[1] + (plot_size / 2):
-                        continue
-                    if tp2 <= config.returnDiggingWindowPos2()[3] + (plot_size / 2):
-                        continue
-                    dig_point(tp1, tp2, DIG_TIME)
-                    # cv.circle(screenshot, (tp1, tp2), 7, (255, 0, 127), -1)
-                    # cv.imshow("screenshot", screenshot)
-                    # cv.waitKey(150)
-                    check_for_ok_button(capture_window, vision_stun, capture_config)
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-
-                tp1 = p1 + (i * plot_size)
-                tp2 = p2 + (i * plot_size)
-                for u in range(0, e, 1):
-                    # left click
-                    tp1 = tp1 - plot_size
-                    if tp2 >= config.returnDiggingWindowPos2()[1] + (plot_size / 2):
-                        continue
-                    dig_point(tp1, tp2, DIG_TIME)
-                    # cv.circle(screenshot, (tp1, tp2), 7, (0, 0, 255), -1)
-                    # cv.imshow("screenshot", screenshot)
-                    # cv.waitKey(150)
-                    check_for_ok_button(capture_window, vision_stun, capture_config)
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-                if keyboard.is_pressed('p') == True or pause == True:
-                    pause = True
-                    break
-            level = level + 1
-
-
-if __name__ == "__main__":
-    run()
-    sys.exit()

equipment.py

@@ -0,0 +1,734 @@
+import random
+from operator import itemgetter
+from time import time
+import cv2 as cv
+from hsvfilter import HsvFilter
+import pydirectinput
+from utils import dig_point
+from game_base_class import GameBase
+from window_capture import WindowCapture
+
+EMITTER_MAIN = "main"
+EMITTER_MUSH = "mushroom"
+EMITTER_AMU = "amulett"
+EMITTER_SWORD = "sword"
+EMITTER_STAFF = "staff"
+EMITTER_WAND = "wand"
+EMITTER_RING = "ring"
+EMITTER_MULTI = "multi"
+
+HSV_DEFAULT = HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0)
+
+
+class Equipment(GameBase):
+    needles = []
+    hsvs = []
+    tresholds = []
+    masks = []
+    emitters = []
+
+    def __init__(self, overlay):
+        super().__init__(overlay)
+
+        # initialize the StunWindowCapture class
+        self.capture_window = WindowCapture(None, "equip", self.config)
+
+        self.EMITTER_TO_USE = str(overlay.emitter_use.get())
+        self.SPAWN_COUNT = int(overlay.spawn_use.get())
+        self.ENERGY_TO_USE = int(overlay.energy_use.get())
+
+        self.init_emitters_to_use()
+
+        self.c_needle = cv.imread("equip/chests/chest_4_32.jpg", cv.IMREAD_UNCHANGED)
+        self.c_mask = cv.imread("equip/chests/chest_4_32-mask.png", cv.IMREAD_COLOR)
+        self.k_needle = cv.imread("equip/keys/key_4_32.jpg", cv.IMREAD_UNCHANGED)
+        self.k_mask = cv.imread("equip/keys/key_4_32-mask.png", cv.IMREAD_COLOR)
+        self.dig_button = cv.imread("dig/ok_button.jpg", cv.IMREAD_UNCHANGED)
+
+        self.energy_counter = 0
+
+    def init_emitters_to_use(self):
+        self.emitters.clear()
+        if self.EMITTER_TO_USE == EMITTER_MULTI:
+            self.emitters.append(EMITTER_RING)
+            self.emitters.append(EMITTER_WAND)
+            self.emitters.append(EMITTER_SWORD)
+            self.emitters.append(EMITTER_AMU)
+            self.emitters.append(EMITTER_STAFF)
+        else:
+            self.emitters.append(self.EMITTER_TO_USE)
+
+    def init_needles_for_emitter_to_use(self, emitter):
+        self.needles.clear()
+        self.hsvs.clear()
+        self.tresholds.clear()
+        self.masks.clear()
+
+        self.include_books()
+        self.include_bags()
+
+        if emitter == EMITTER_MUSH:
+            self.include_mushs()
+            self.include_pots()
+        elif emitter == EMITTER_AMU:
+            self.include_amus()
+        elif emitter == EMITTER_MAIN:
+            self.include_chests()
+            self.include_keys()
+            self.include_pots()
+            #self.include_coins()
+            self.include_runes()
+        elif emitter == EMITTER_SWORD:
+            self.include_swords()
+        elif emitter == EMITTER_STAFF:
+            self.include_staffs()
+        elif emitter == EMITTER_RING:
+            self.include_rings()
+        elif emitter == EMITTER_WAND:
+            self.include_wands()
+
+    def execute_main_loop(self):
+        start_time = time()
+        breaks = self.init_breaks()
+        for emitter in self.emitters:
+            self.init_needles_for_emitter_to_use(emitter)
+            while True:
+                self.check_breaks(start_time, breaks)
+                if self.overlay.run_mode == 'paused':
+                    cv.waitKey(10)
+                    continue
+                elif self.overlay.run_mode == 'stopped':
+                    break
+
+                # get an updated image of the game
+                screenshot = self.capture_window.get_screenshot()
+
+                # cv.imshow("screenshot", screenshot)
+                # cv.waitKey(150)
+                # continue
+                if self.energy_counter >= self.ENERGY_TO_USE:
+                    self.energy_counter = 0
+                    break
+
+                spawn_1 = self.find_emitter(emitter, screenshot, 1)
+                if len(spawn_1) == 1:
+                    #output_by_area = self.vision_stun.draw_rectangles(screenshot, spawn_1)
+                    #cv.imshow("spawn_1", output_by_area)
+                    #cv.waitKey(150)
+                    points = self.vision_stun.get_click_points(spawn_1)
+                    for i in range(0, self.SPAWN_COUNT, 1):
+                        self.click_point(points[0][0], points[0][1])
+                        self.energy_counter = self.energy_counter + 1
+                        self.overlay.update_status_label(emitter + ": " + str(self.ENERGY_TO_USE - self.energy_counter))
+                        if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                            break
+                else:
+                    spawn_0 = self.find_emitter(emitter, screenshot, 0)
+                    points = self.vision_stun.get_click_points(spawn_0)
+                    if len(points) >= 1:
+                        self.click_point(points[0][0], points[0][1])
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        continue
+                    continue
+
+                cv.waitKey(500)
+
+                if emitter == EMITTER_MAIN:
+                    loop_time = time()
+                    while True:
+                        if (time() - loop_time) >= 10:
+                            break
+                        screenshot = self.capture_window.get_screenshot()
+                        c_rectangles = self.vision_stun.find(screenshot, self.c_needle, 0.95, 1, True, self.c_mask)
+                        k_rectangles = self.vision_stun.find(screenshot, self.k_needle, 0.95, 1, True, self.k_mask)
+                        if (len(c_rectangles) == 1) and (len(k_rectangles) == 1):
+                            c_point = self.vision_stun.get_click_points(c_rectangles)[0]
+                            k_point = self.vision_stun.get_click_points(k_rectangles)[0]
+                            self.move_tile(k_point, c_point)
+                            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                                break
+                        else:
+                            break
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        continue
+
+                for rer in range(0, len(self.needles), 1):
+                    loop_time = time()
+                    while True:
+                        if (time() - loop_time) >= 20:
+                            break
+                        screenshot = self.capture_window.get_screenshot_by_area(self.config.returnOKWindowPos())
+                        rectangles = self.vision_stun.find(screenshot, self.dig_button, 0.5, 1)
+                        if len(rectangles) == 1:
+                            pointis = self.vision_stun.get_click_points(rectangles)
+                            for pointi in pointis:
+                                dig_point(pointi[0] + self.config.returnOKWindowPos()[2],
+                                          pointi[1] + self.config.returnOKWindowPos()[3], 150)
+                                cv.waitKey(60000)
+                                continue
+                        # do object detection
+                        screenshot = self.capture_window.get_screenshot()
+                        # processed_screenshot = self.vision_stun.apply_hsv_filter(screenshot, self.hsvs[rer])
+                        # processed_needle = self.vision_stun.apply_hsv_filter(self.needles[rer], self.hsvs[rer])
+
+                        rectangles = self.vision_stun.find_by_mask_and_validate(screenshot, self.needles[rer],
+                                                                                self.masks[rer], 5)
+                        # draw the detection results onto the original image
+                        # output_image = self.vision_stun.draw_rectangles(screenshot, rectangles)
+                        # cv.imshow("output_image", output_image)
+                        # cv.waitKey(150)
+
+                        if len(rectangles) is not 5:
+                            break
+                        if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                            break
+
+                        # sort rectangles by top
+                        rectangles = sorted(rectangles, key=itemgetter(1))
+
+                        points = self.vision_stun.get_click_points(rectangles)
+
+                        move_breaker = self.check_and_move_tile([70, 70, rectangles[0][0] + 70, rectangles[0][1]],
+                                                                self.needles[rer],
+                                                                points[1], [points[0][0] + 70, points[0][1]])
+                        if move_breaker:
+                            break
+                        if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                            break
+                        move_breaker = self.check_and_move_tile([70, 70, rectangles[0][0], rectangles[0][1] + 70],
+                                                                self.needles[rer],
+                                                                points[2], [points[0][0], points[0][1] + 70])
+                        if move_breaker:
+                            break
+                        if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                            break
+                        move_breaker = self.check_and_move_tile([70, 70, rectangles[0][0] + 70, rectangles[0][1] + 70],
+                                                                self.needles[rer],
+                                                                points[3], [points[0][0] + 70, points[0][1] + 70])
+                        if move_breaker:
+                            break
+                        self.move_tile(points[4], [points[0][0], points[0][1]])
+                        if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                            break
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        break
+                cv.waitKey(150)
+                if self.overlay.run_mode == 'stopped':
+                    break
+            if self.overlay.run_mode == 'stopped':
+                break
+        self.overlay.run_mode = 'finished'
+
+    def check_and_move_tile(self, rect, needl, point_source, point_dest):
+        screenshot_p = self.capture_window.get_screenshot()
+        screenshot_p_w = screenshot_p.shape[1]
+        screenshot_p_h = screenshot_p.shape[0]
+        w = rect[0]
+        h = rect[1]
+        x = rect[2]
+        y = rect[3]
+        if h >= screenshot_p_h or w >= screenshot_p_w:
+            return True
+
+        screenshot_pos = screenshot_p[y:y + h, x:x + w]  # (w, h, x+w, y+h)
+        # processed_screenshot = visio.apply_hsv_filter(screenshot_pos, hsv)
+        # processed_needle = visio.apply_hsv_filter(needl, hsv)
+        result2 = cv.matchTemplate(screenshot_pos, needl, cv.TM_CCOEFF_NORMED)
+        _min_val2, _max_val2, min_loc2, max_loc2 = cv.minMaxLoc(result2, None)
+        # rectangles2 = visio.find(screenshot_pos, needl, tresh, 1, True, mask)
+        # output_by_area = self.vision_stun.draw_rectangles(screenshot_pos2, rectangles)
+        # cv.imshow("output_image_by_area", screenshot_pos)
+        # cv.waitKey(150)
+        # print("thresh in movecheck:" + str(_maxVal2))
+        if _max_val2 <= 0.9:
+            self.move_tile(point_source, point_dest)
+
+        return False
+
+    def click_point(self, x, y):
+        offset_left = self.config.returnEquipmentWindowPos()[2]
+        offset_down = self.config.returnEquipmentWindowPos()[3]
+        pydirectinput.moveTo(x + offset_left, y + offset_down)
+        pydirectinput.mouseDown()
+        w = random.randint(1, 50)
+        cv.waitKey(30 + w)
+        pydirectinput.mouseUp()
+
+    def move_tile(self, point_source, point_dest):
+        offset_left = self.config.returnEquipmentWindowPos()[2]
+        offset_down = self.config.returnEquipmentWindowPos()[3]
+        pydirectinput.moveTo(point_source[0] + offset_left, point_source[1] + offset_down)
+        pydirectinput.mouseDown()
+        w = random.randint(25, 50)
+        cv.waitKey(100 + w)
+        pydirectinput.moveTo(point_dest[0] + offset_left, point_dest[1] + offset_down)
+        pydirectinput.mouseUp()
+        cv.waitKey(400 + w)
+
+    def find_emitter(self, emitter_to_use, screen, layer):
+        if self.EMITTER_TO_USE == EMITTER_MUSH:
+            if layer == 0:
+                needle = cv.imread("equip/emitters/mush_e_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/mush_e_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, True, mask)
+            else:
+                needle = cv.imread("equip/emitters/mush_e2_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/mush_e2_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.98, 1, True, mask)
+        elif emitter_to_use == EMITTER_AMU:
+            if layer == 0:
+                needle = cv.imread("equip/emitters/amu_e_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/amu_e_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, True, mask)
+            else:
+                needle = cv.imread("equip/emitters/amu_e2_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/amu_e2_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, True, mask)
+        elif emitter_to_use == EMITTER_MAIN:
+            if layer == 0:
+                needle = cv.imread("equip/emitters/main_e1_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/main_e1_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, True, mask)
+            else:
+                needle = cv.imread("equip/emitters/main_e2_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/main_e2_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, True, mask)
+        elif emitter_to_use == EMITTER_SWORD:
+            if layer == 0:
+                needle = cv.imread("equip/emitters/sword_e1_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/sword_e1_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, True, mask)
+            else:
+                needle = cv.imread("equip/emitters/sword_e2_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/sword_e2_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.98, 1, True, mask)
+        elif emitter_to_use == EMITTER_STAFF:
+            if layer == 0:
+                needle = cv.imread("equip/emitters/staff_e1_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/staff_e1_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, True, mask)
+            else:
+                needle = cv.imread("equip/emitters/staff_e2_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/staff_e2_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.99, 1, True, mask)
+        elif emitter_to_use == EMITTER_RING:
+            if layer == 0:
+                needle = cv.imread("equip/emitters/ring_e1_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/ring_e1_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, True, mask)
+            else:
+                needle = cv.imread("equip/emitters/ring_e2_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/ring_e2_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, False, mask)
+        elif emitter_to_use == EMITTER_WAND:
+            if layer == 0:
+                needle = cv.imread("equip/emitters/wand_e1_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/wand_e1_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.95, 1, True, mask)
+            else:
+                needle = cv.imread("equip/emitters/wand_e2_32.jpg", cv.IMREAD_UNCHANGED)
+                mask = cv.imread("equip/emitters/wand_e2_32-mask.png", cv.IMREAD_COLOR)
+                return self.vision_stun.find(screen, needle, 0.96, 1, True, mask)
+
+    def include_chests(self):
+        self.needles.append(cv.imread("equip/chests/chest_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.95)
+        self.masks.append(cv.imread("equip/chests/chest_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/chests/chest_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.95)
+        self.masks.append(cv.imread("equip/chests/chest_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/chests/chest_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/chests/chest_3_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_books(self):
+        self.needles.append(cv.imread("equip/books/book_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/books/book_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/books/book_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.9)
+        self.masks.append(cv.imread("equip/books/book_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/books/book_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.87)
+        self.masks.append(cv.imread("equip/books/book_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/books/book_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/books/book_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/books/book_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/books/book_5_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/books/book_6_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.9)
+        self.masks.append(cv.imread("equip/books/book_6_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/books/book_7_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/books/book_7_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/books/book_8_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/books/book_8_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_keys(self):
+        self.needles.append(cv.imread("equip/keys/key_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/keys/key_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/keys/key_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/keys/key_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/keys/key_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/keys/key_3_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_pots(self):
+        self.needles.append(cv.imread("equip/pots/pot_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/pots/pot_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/pots/pot_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/pots/pot_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/pots/pot_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.94)
+        self.masks.append(cv.imread("equip/pots/pot_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/pots/pot_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/pots/pot_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/pots/pot_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/pots/pot_5_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/pots/pot_6_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/pots/pot_6_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_bags(self):
+        self.needles.append(cv.imread("equip/bags/bag_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/bags/bag_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/bags/bag_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.88)
+        self.masks.append(cv.imread("equip/bags/bag_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/bags/bag_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/bags/bag_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/bags/bag_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/bags/bag_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/bags/bag_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/bags/bag_5_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/bags/bag_6_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/bags/bag_6_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/bags/bag_7_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/bags/bag_7_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_coins(self):
+        self.needles.append(cv.imread("equip/coins/coin_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/coins/coin_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/coins/coin_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/coins/coin_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/coins/coin_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/coins/coin_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/coins/coin_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/coins/coin_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/coins/coin_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/coins/coin_5_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_runes(self):
+        self.needles.append(cv.imread("equip/runes/rune_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/runes/rune_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/runes/rune_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/runes/rune_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/runes/rune_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/runes/rune_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/runes/rune_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/runes/rune_4_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_mushs(self):
+        self.needles.append(cv.imread("equip/mushrooms/mush_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/mushrooms/mush_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/mushrooms/mush_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/mushrooms/mush_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/mushrooms/mush_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/mushrooms/mush_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/mushrooms/mush_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/mushrooms/mush_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/mushrooms/mush_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/mushrooms/mush_5_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/mushrooms/mush_6_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/mushrooms/mush_6_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/mushrooms/mush_7_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/mushrooms/mush_7_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_amus(self):
+        self.needles.append(cv.imread("equip/amus/amu_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.9)
+        self.masks.append(cv.imread("equip/amus/amu_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/amus/amu_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.9)
+        self.masks.append(cv.imread("equip/amus/amu_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/amus/amu_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/amus/amu_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/amus/amu_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/amus/amu_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/amus/amu_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/amus/amu_5_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/amus/amu_6_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/amus/amu_6_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/amus/amu_7_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/amus/amu_7_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_swords(self):
+        self.needles.append(cv.imread("equip/swords/sword_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/swords/sword_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/swords/sword_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/swords/sword_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/swords/sword_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/swords/sword_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/swords/sword_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/swords/sword_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/swords/sword_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/swords/sword_5_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/swords/sword_6_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/swords/sword_6_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/swords/sword_7_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/swords/sword_7_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_staffs(self):
+        self.needles.append(cv.imread("equip/staffs/staff_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.94)
+        self.masks.append(cv.imread("equip/staffs/staff_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/staffs/staff_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.94)
+        self.masks.append(cv.imread("equip/staffs/staff_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/staffs/staff_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/staffs/staff_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/staffs/staff_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/staffs/staff_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/staffs/staff_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/staffs/staff_5_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/staffs/staff_6_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/staffs/staff_6_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/staffs/staff_7_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/staffs/staff_7_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_rings(self):
+        self.needles.append(cv.imread("equip/rings/ring_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.925)
+        self.masks.append(cv.imread("equip/rings/ring_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/rings/ring_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.94)
+        self.masks.append(cv.imread("equip/rings/ring_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/rings/ring_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/rings/ring_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/rings/ring_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/rings/ring_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/rings/ring_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/rings/ring_5_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/rings/ring_6_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.91)
+        self.masks.append(cv.imread("equip/rings/ring_6_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/rings/ring_7_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/rings/ring_7_32-mask.png", cv.IMREAD_COLOR))
+
+    def include_wands(self):
+        self.needles.append(cv.imread("equip/wands/wand_1_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/wands/wand_1_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/wands/wand_2_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/wands/wand_2_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/wands/wand_3_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/wands/wand_3_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/wands/wand_4_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/wands/wand_4_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/wands/wand_5_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/wands/wand_5_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/wands/wand_6_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/wands/wand_6_32-mask.png", cv.IMREAD_COLOR))
+
+        self.needles.append(cv.imread("equip/wands/wand_7_32.jpg", cv.IMREAD_UNCHANGED))
+        self.hsvs.append(HSV_DEFAULT)
+        self.tresholds.append(0.93)
+        self.masks.append(cv.imread("equip/wands/wand_7_32-mask.png", cv.IMREAD_COLOR))

equipment_main.py

@@ -1,769 +0,0 @@
-import random
-from operator import itemgetter
-from time import time
-from window_capture import WindowCapture
-from vision import Vision
-import cv2 as cv
-from hsvfilter import HsvFilter
-from config_file import UserConfigs
-import pydirectinput
-import keyboard
-from utils import dig_point
-
-EMITTER_MAIN = "main"
-EMITTER_MUSH = "mushroom"
-EMITTER_AMU = "amulett"
-EMITTER_SWORD = "sword"
-EMITTER_STAFF = "staff"
-EMITTER_WAND = "wand"
-EMITTER_RING = "ring"
-EMITTER_MULTI = "all"
-
-HSV_DEFAULT = HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0)
-
-
-def run():
-    EMITTER_TO_USE = EMITTER_MULTI
-    SPAWN_COUNT = 25
-    ENERGY_TO_USE = 3000
-    # initialize the user-class
-    config = UserConfigs()
-
-    # initialize the StunWindowCapture class
-    try:
-        capture_window = WindowCapture(
-            None, "equip", config)
-    except:
-        # StunWindowCapture.list_window_names()
-        print("Game not running, exiting")
-        # capture_window = cv.VideoCapture("snip_slam.mp4")
-        return
-
-    # initialize the StunVision class
-    vision_stun = Vision()
-
-    outer_loop_time = time()
-
-    needles = []
-    hsvs = []
-    tresholds = []
-    masks = []
-    emitters = []
-
-    if EMITTER_TO_USE == EMITTER_MULTI:
-        emitters.append(EMITTER_RING)
-        emitters.append(EMITTER_WAND)
-        emitters.append(EMITTER_SWORD)
-        emitters.append(EMITTER_STAFF)
-        emitters.append(EMITTER_AMU)
-    else:
-        emitters.append(EMITTER_TO_USE)
-
-    energy_counter = 0
-    pause = True
-    for emitter in emitters:
-        if emitter == EMITTER_MUSH:
-            include_books(needles, hsvs, tresholds, masks)
-            include_mushs(needles, hsvs, tresholds, masks)
-            include_pots(needles, hsvs, tresholds, masks)
-            include_bags(needles, hsvs, tresholds, masks)
-        elif emitter == EMITTER_AMU:
-            include_books(needles, hsvs, tresholds, masks)
-            include_amus(needles, hsvs, tresholds, masks)
-            include_bags(needles, hsvs, tresholds, masks)
-        elif emitter == EMITTER_MAIN:
-            include_books(needles, hsvs, tresholds, masks)
-            include_chests(needles, hsvs, tresholds, masks)
-            include_keys(needles, hsvs, tresholds, masks)
-            include_pots(needles, hsvs, tresholds, masks)
-            include_bags(needles, hsvs, tresholds, masks)
-            include_coins(needles, hsvs, tresholds, masks)
-            include_runes(needles, hsvs, tresholds, masks)
-        elif emitter == EMITTER_SWORD:
-            include_books(needles, hsvs, tresholds, masks)
-            include_swords(needles, hsvs, tresholds, masks)
-            include_bags(needles, hsvs, tresholds, masks)
-        elif emitter == EMITTER_STAFF:
-            include_books(needles, hsvs, tresholds, masks)
-            include_staffs(needles, hsvs, tresholds, masks)
-            include_bags(needles, hsvs, tresholds, masks)
-        elif emitter == EMITTER_RING:
-            include_books(needles, hsvs, tresholds, masks)
-            include_rings(needles, hsvs, tresholds, masks)
-            include_bags(needles, hsvs, tresholds, masks)
-        elif emitter == EMITTER_WAND:
-            include_books(needles, hsvs, tresholds, masks)
-            include_wands(needles, hsvs, tresholds, masks)
-            include_bags(needles, hsvs, tresholds, masks)
-
-        c_needle = cv.imread("equip/chests/chest_4_32.jpg", cv.IMREAD_UNCHANGED)
-        c_mask = cv.imread("equip/chests/chest_4_32-mask.png", cv.IMREAD_COLOR)
-        k_needle = cv.imread("equip/keys/key_4_32.jpg", cv.IMREAD_UNCHANGED)
-        k_mask = cv.imread("equip/keys/key_4_32-mask.png", cv.IMREAD_COLOR)
-        dig_button = cv.imread("dig/ok_button.jpg", cv.IMREAD_UNCHANGED)
-        loop_time_p = time()
-
-        while True:
-            if keyboard.is_pressed('p') == True:
-                pause = True
-                print('q pressed')
-            elif keyboard.is_pressed('o') == True:
-                pause = False
-                print('o pressed')
-
-            if pause:
-                # cv.waitKey(500)
-                if (time() - loop_time_p) >= 5:
-                    loop_time_p = time()
-                    print("pausing")
-                continue
-
-            try:
-                # get an updated image of the game
-                screenshot = capture_window.get_screenshot()
-                # screenshot = cv.imread("buffbar.jpg")
-            except:
-                capture_window.release()
-                print("Game window not available - shutting down application")
-                break
-            # cv.imshow("screenshot", screenshot)
-            # cv.waitKey(150)
-            # continue
-            if energy_counter >= ENERGY_TO_USE:
-                energy_counter = 0
-                break
-
-            spawn_1 = find_emitter(emitter, vision_stun, screenshot, 1)
-            if len(spawn_1) == 1:
-                spawn_button_active = True
-                points = vision_stun.get_click_points(spawn_1)
-                for i in range(0, SPAWN_COUNT, 1):
-                    click_point(config, points[0][0], points[0][1])
-                    energy_counter = energy_counter + 1
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-            else:
-                spawn_0 = find_emitter(emitter, vision_stun, screenshot, 0)
-                points = vision_stun.get_click_points(spawn_0)
-                for point in points:
-                    click_point(config, points[0][0], points[0][1])
-
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-                continue
-
-            cv.waitKey(500)
-
-            if emitter == EMITTER_MAIN:
-                while True:
-                    screenshot = capture_window.get_screenshot()
-                    c_rectangles = vision_stun.find(screenshot, c_needle, 0.95, 1, True, c_mask)
-                    k_rectangles = vision_stun.find(screenshot, k_needle, 0.95, 1, True, k_mask)
-                    if (len(c_rectangles) == 1) and (len(k_rectangles) == 1):
-                        c_point = vision_stun.get_click_points(c_rectangles)[0]
-                        k_point = vision_stun.get_click_points(k_rectangles)[0]
-                        move_tile(config, k_point, c_point)
-                    else:
-                        break
-
-            for rer in range(0, len(needles), 1):
-                loop_time = time()
-                while True:
-                    if (time() - loop_time) >= 60:
-                        break
-                    screenshot = capture_window.get_screenshot_by_area(config.returnOKWindowPos())
-                    rectangles = vision_stun.find(screenshot, dig_button, 0.5, 1)
-                    if len(rectangles) == 1:
-                        pointis = vision_stun.get_click_points(rectangles)
-                        for pointi in pointis:
-                            dig_point(pointi[0] + config.returnOKWindowPos()[2],
-                                      pointi[1] + config.returnOKWindowPos()[3], 150)
-                            cv.waitKey(60000)
-                            continue
-                    # do object detection
-                    screenshot = capture_window.get_screenshot()
-                    # processed_screenshot = vision_stun.apply_hsv_filter(screenshot, hsvs[rer])
-                    # processed_needle = vision_stun.apply_hsv_filter(needles[rer], hsvs[rer])
-
-                    rectangles = vision_stun.find_by_mask_and_validate(screenshot, needles[rer], masks[rer], 5)
-                    # draw the detection results onto the original image
-                    # output_image = vision_stun.draw_rectangles(screenshot, rectangles)
-                    # cv.imshow("output_image", output_image)
-                    # cv.waitKey(150)
-
-                    if len(rectangles) is not 5:
-                        break
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-
-                    # sort rectangles by top
-                    rectangles = sorted(rectangles, key=itemgetter(1))
-
-                    points = vision_stun.get_click_points(rectangles)
-
-                    move_breaker = check_and_move_tile(capture_window, vision_stun, config,
-                                                       [70, 70, rectangles[0][0] + 70, rectangles[0][1]], needles[rer],
-                                                       hsvs[rer], tresholds[rer], masks[rer],
-                                                       points[1], [points[0][0] + 70, points[0][1]])
-                    if move_breaker:
-                        break
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-                    move_breaker = check_and_move_tile(capture_window, vision_stun, config,
-                                                       [70, 70, rectangles[0][0], rectangles[0][1] + 70], needles[rer],
-                                                       hsvs[rer], tresholds[rer], masks[rer],
-                                                       points[2], [points[0][0], points[0][1] + 70])
-                    if move_breaker:
-                        break
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-                    move_breaker = check_and_move_tile(capture_window, vision_stun, config,
-                                                       [70, 70, rectangles[0][0] + 70, rectangles[0][1] + 70],
-                                                       needles[rer], hsvs[rer], tresholds[rer], masks[rer],
-                                                       points[3], [points[0][0] + 70, points[0][1] + 70])
-                    if move_breaker:
-                        break
-                    move_tile(config, points[4], [points[0][0], points[0][1]])
-                    if keyboard.is_pressed('p') == True or pause == True:
-                        pause = True
-                        break
-            # debug the loop rate
-            print('FPS {}'.format(1 / (time() - outer_loop_time)))
-            outer_loop_time = time()
-            cv.waitKey(150)
-
-
-def check_and_move_tile(capture_win, visio, conf, rect, needl, hsv, tresh, mask, point_source, point_dest):
-    screenshot_p = capture_win.get_screenshot()
-    screenshot_p_w = screenshot_p.shape[1]
-    screenshot_p_h = screenshot_p.shape[0]
-    w = rect[0]
-    h = rect[1]
-    x = rect[2]
-    y = rect[3]
-    if h >= screenshot_p_h or w >= screenshot_p_w:
-        return True
-
-    screenshot_pos = screenshot_p[y:y + h, x:x + w]  # (w, h, x+w, y+h)
-    # processed_screenshot = visio.apply_hsv_filter(screenshot_pos, hsv)
-    # processed_needle = visio.apply_hsv_filter(needl, hsv)
-    result2 = cv.matchTemplate(screenshot_pos, needl, cv.TM_CCOEFF_NORMED)
-    _minVal2, _maxVal2, minLoc2, maxLoc2 = cv.minMaxLoc(result2, None)
-    # rectangles2 = visio.find(screenshot_pos, needl, tresh, 1, True, mask)
-    # output_by_area = vision_stun.draw_rectangles(screenshot_pos2, rectangles)
-    # cv.imshow("output_image_by_area", screenshot_pos)
-    # cv.waitKey(150)
-    # print("thresh in movecheck:" + str(_maxVal2))
-    if _maxVal2 <= 0.9:
-        move_tile(conf, point_source, point_dest)
-
-    return False
-
-
-def click_point(conf, x, y):
-    offset_left = conf.returnEquipmentWindowPos()[2]
-    offset_down = conf.returnEquipmentWindowPos()[3]
-    pydirectinput.moveTo(x + offset_left, y + offset_down)
-    pydirectinput.mouseDown()
-    w = random.randint(1, 50)
-    cv.waitKey(30 + w)
-    pydirectinput.mouseUp()
-
-
-def move_tile(conf, point_source, point_dest):
-    offset_left = conf.returnEquipmentWindowPos()[2]
-    offset_down = conf.returnEquipmentWindowPos()[3]
-    pydirectinput.moveTo(point_source[0] + offset_left, point_source[1] + offset_down)
-    pydirectinput.mouseDown()
-    w = random.randint(25, 50)
-    cv.waitKey(100 + w)
-    pydirectinput.moveTo(point_dest[0] + offset_left, point_dest[1] + offset_down)
-    pydirectinput.mouseUp()
-    cv.waitKey(400 + w)
-
-
-def find_emitter(emitter_to_use, vis, screen, layer):
-    if emitter_to_use == EMITTER_MUSH:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/mush_e_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/mush_e_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/mush_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/mush_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.98, 1, True, mask)
-    elif emitter_to_use == EMITTER_AMU:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/amu_e_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/amu_e_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/amu_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/amu_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-    elif emitter_to_use == EMITTER_MAIN:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/main_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/main_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/main_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/main_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-    elif emitter_to_use == EMITTER_SWORD:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/sword_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/sword_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/sword_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/sword_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.98, 1, True, mask)
-    elif emitter_to_use == EMITTER_STAFF:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/staff_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/staff_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/staff_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/staff_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.99, 1, True, mask)
-    elif emitter_to_use == EMITTER_RING:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/ring_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/ring_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/ring_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/ring_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-    elif emitter_to_use == EMITTER_WAND:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/wand_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/wand_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/wand_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/wand_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.96, 1, True, mask)
-
-
-def include_chests(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/chests/chest_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.95)
-    mask.append(cv.imread("equip/chests/chest_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/chests/chest_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.95)
-    mask.append(cv.imread("equip/chests/chest_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/chests/chest_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/chests/chest_3_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_books(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/books/book_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/books/book_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.9)
-    mask.append(cv.imread("equip/books/book_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.87)
-    mask.append(cv.imread("equip/books/book_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/books/book_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/books/book_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.9)
-    mask.append(cv.imread("equip/books/book_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/books/book_7_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_8_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/books/book_8_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_keys(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/keys/key_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/keys/key_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/keys/key_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/keys/key_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/keys/key_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/keys/key_3_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_pots(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/pots/pot_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.94)
-    mask.append(cv.imread("equip/pots/pot_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_6_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_bags(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/bags/bag_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.88)
-    mask.append(cv.imread("equip/bags/bag_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_coins(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/coins/coin_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/coins/coin_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/coins/coin_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/coins/coin_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/coins/coin_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_5_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_runes(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/runes/rune_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/runes/rune_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/runes/rune_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/runes/rune_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/runes/rune_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/runes/rune_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/runes/rune_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/runes/rune_4_32-mask.png", cv.IMREAD_COLOR))
-
-def include_mushs(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/mushrooms/mush_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_amus(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/amus/amu_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.9)
-    mask.append(cv.imread("equip/amus/amu_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.9)
-    mask.append(cv.imread("equip/amus/amu_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_swords(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/swords/sword_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_7_32-mask.png", cv.IMREAD_COLOR))
-
-def include_staffs(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/staffs/staff_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_rings(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/rings/ring_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.925)
-    mask.append(cv.imread("equip/rings/ring_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.94)
-    mask.append(cv.imread("equip/rings/ring_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/rings/ring_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/rings/ring_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/rings/ring_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/rings/ring_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/rings/ring_7_32-mask.png", cv.IMREAD_COLOR))
-
-def include_wands(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/wands/wand_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_7_32-mask.png", cv.IMREAD_COLOR))
-
-if __name__ == "__main__":
-    run()

equipment_main_ui.py

@@ -1,787 +0,0 @@
-import random
-from operator import itemgetter
-from time import time
-
-import equipment_overlay
-from window_capture import WindowCapture
-from vision import Vision
-import cv2 as cv
-from hsvfilter import HsvFilter
-from config_file import UserConfigs
-import pydirectinput
-import keyboard
-from utils import dig_point
-from equipment_overlay import EquipmentOverlay
-
-EMITTER_MAIN = "main"
-EMITTER_MUSH = "mushroom"
-EMITTER_AMU = "amulett"
-EMITTER_SWORD = "sword"
-EMITTER_STAFF = "staff"
-EMITTER_WAND = "wand"
-EMITTER_RING = "ring"
-EMITTER_MULTI = "multi"
-
-HSV_DEFAULT = HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0)
-
-
-def run():
-    config = UserConfigs()
-    overlay = EquipmentOverlay(config)
-
-    while True:
-        if overlay.run_mode == 'stopped':
-            overlay.update_status_label("stopped", "0")
-            overlay.run_mode = 'init'
-            continue
-        elif overlay.run_mode == 'started':
-            pass
-        elif overlay.run_mode == 'init':
-            continue
-        elif overlay.run_mode == 'paused':
-            continue
-        else:
-            break
-
-        EMITTER_TO_USE = str(overlay.emitter_use.get())
-        SPAWN_COUNT = int(overlay.spawn_use.get())
-        ENERGY_TO_USE = int(overlay.energy_use.get())
-
-        # initialize the StunWindowCapture class
-        try:
-            capture_window = WindowCapture(
-                None, "equip", config)
-        except:
-            # StunWindowCapture.list_window_names()
-            print("Game not running, exiting")
-            # capture_window = cv.VideoCapture("snip_slam.mp4")
-            return
-
-        # initialize the StunVision class
-        vision_stun = Vision()
-
-        outer_loop_time = time()
-
-        needles = []
-        hsvs = []
-        tresholds = []
-        masks = []
-        emitters = []
-
-        if EMITTER_TO_USE == EMITTER_MULTI:
-            emitters.append(EMITTER_RING)
-            emitters.append(EMITTER_WAND)
-            emitters.append(EMITTER_SWORD)
-            emitters.append(EMITTER_AMU)
-            emitters.append(EMITTER_STAFF)
-        else:
-            emitters.append(EMITTER_TO_USE)
-
-        energy_counter = 0
-
-        for emitter in emitters:
-            if overlay.run_mode == 'stopped':
-                break
-            if emitter == EMITTER_MUSH:
-                include_books(needles, hsvs, tresholds, masks)
-                include_mushs(needles, hsvs, tresholds, masks)
-                include_pots(needles, hsvs, tresholds, masks)
-                include_bags(needles, hsvs, tresholds, masks)
-            elif emitter == EMITTER_AMU:
-                include_books(needles, hsvs, tresholds, masks)
-                include_amus(needles, hsvs, tresholds, masks)
-                include_bags(needles, hsvs, tresholds, masks)
-            elif emitter == EMITTER_MAIN:
-                include_books(needles, hsvs, tresholds, masks)
-                include_chests(needles, hsvs, tresholds, masks)
-                include_keys(needles, hsvs, tresholds, masks)
-                include_pots(needles, hsvs, tresholds, masks)
-                include_bags(needles, hsvs, tresholds, masks)
-                include_coins(needles, hsvs, tresholds, masks)
-                include_runes(needles, hsvs, tresholds, masks)
-            elif emitter == EMITTER_SWORD:
-                include_books(needles, hsvs, tresholds, masks)
-                include_swords(needles, hsvs, tresholds, masks)
-                include_bags(needles, hsvs, tresholds, masks)
-            elif emitter == EMITTER_STAFF:
-                include_books(needles, hsvs, tresholds, masks)
-                include_staffs(needles, hsvs, tresholds, masks)
-                include_bags(needles, hsvs, tresholds, masks)
-            elif emitter == EMITTER_RING:
-                include_books(needles, hsvs, tresholds, masks)
-                include_rings(needles, hsvs, tresholds, masks)
-                include_bags(needles, hsvs, tresholds, masks)
-            elif emitter == EMITTER_WAND:
-                include_books(needles, hsvs, tresholds, masks)
-                include_wands(needles, hsvs, tresholds, masks)
-                include_bags(needles, hsvs, tresholds, masks)
-
-            c_needle = cv.imread("equip/chests/chest_4_32.jpg", cv.IMREAD_UNCHANGED)
-            c_mask = cv.imread("equip/chests/chest_4_32-mask.png", cv.IMREAD_COLOR)
-            k_needle = cv.imread("equip/keys/key_4_32.jpg", cv.IMREAD_UNCHANGED)
-            k_mask = cv.imread("equip/keys/key_4_32-mask.png", cv.IMREAD_COLOR)
-            dig_button = cv.imread("dig/ok_button.jpg", cv.IMREAD_UNCHANGED)
-            loop_time_p = time()
-
-            while True:
-                if overlay.run_mode == 'paused':
-                    # cv.waitKey(500)
-                    if (time() - loop_time_p) >= 5:
-                        loop_time_p = time()
-                        print("pausing")
-                    continue
-                elif overlay.run_mode == 'stopped':
-                    break
-
-                try:
-                    # get an updated image of the game
-                    screenshot = capture_window.get_screenshot()
-                    # screenshot = cv.imread("buffbar.jpg")
-                except:
-                    capture_window.release()
-                    print("Game window not available - shutting down application")
-                    break
-                # cv.imshow("screenshot", screenshot)
-                # cv.waitKey(150)
-                # continue
-                if energy_counter >= ENERGY_TO_USE:
-                    energy_counter = 0
-                    break
-
-                spawn_1 = find_emitter(emitter, vision_stun, screenshot, 1)
-                if len(spawn_1) == 1:
-                    spawn_button_active = True
-                    points = vision_stun.get_click_points(spawn_1)
-                    for i in range(0, SPAWN_COUNT, 1):
-                        click_point(config, points[0][0], points[0][1])
-                        energy_counter = energy_counter + 1
-                        overlay.update_status_label(emitter, ENERGY_TO_USE - energy_counter)
-                        if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused':
-                            break
-                else:
-                    spawn_0 = find_emitter(emitter, vision_stun, screenshot, 0)
-                    points = vision_stun.get_click_points(spawn_0)
-                    for point in points:
-                        click_point(config, points[0][0], points[0][1])
-
-                        if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused':
-                            break
-                    continue
-
-                cv.waitKey(500)
-
-                if emitter == EMITTER_MAIN:
-                    while True:
-                        screenshot = capture_window.get_screenshot()
-                        c_rectangles = vision_stun.find(screenshot, c_needle, 0.95, 1, True, c_mask)
-                        k_rectangles = vision_stun.find(screenshot, k_needle, 0.95, 1, True, k_mask)
-                        if (len(c_rectangles) == 1) and (len(k_rectangles) == 1):
-                            c_point = vision_stun.get_click_points(c_rectangles)[0]
-                            k_point = vision_stun.get_click_points(k_rectangles)[0]
-                            move_tile(config, k_point, c_point)
-                        else:
-                            break
-
-                for rer in range(0, len(needles), 1):
-                    loop_time = time()
-                    while True:
-                        if (time() - loop_time) >= 60:
-                            break
-                        screenshot = capture_window.get_screenshot_by_area(config.returnOKWindowPos())
-                        rectangles = vision_stun.find(screenshot, dig_button, 0.5, 1)
-                        if len(rectangles) == 1:
-                            pointis = vision_stun.get_click_points(rectangles)
-                            for pointi in pointis:
-                                dig_point(pointi[0] + config.returnOKWindowPos()[2],
-                                          pointi[1] + config.returnOKWindowPos()[3], 150)
-                                cv.waitKey(60000)
-                                continue
-                        # do object detection
-                        screenshot = capture_window.get_screenshot()
-                        # processed_screenshot = vision_stun.apply_hsv_filter(screenshot, hsvs[rer])
-                        # processed_needle = vision_stun.apply_hsv_filter(needles[rer], hsvs[rer])
-
-                        rectangles = vision_stun.find_by_mask_and_validate(screenshot, needles[rer], masks[rer], 5)
-                        # draw the detection results onto the original image
-                        # output_image = vision_stun.draw_rectangles(screenshot, rectangles)
-                        # cv.imshow("output_image", output_image)
-                        # cv.waitKey(150)
-
-                        if len(rectangles) is not 5:
-                            break
-                        if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused':
-                            break
-
-                        # sort rectangles by top
-                        rectangles = sorted(rectangles, key=itemgetter(1))
-
-                        points = vision_stun.get_click_points(rectangles)
-
-                        move_breaker = check_and_move_tile(capture_window, vision_stun, config,
-                                                           [70, 70, rectangles[0][0] + 70, rectangles[0][1]],
-                                                           needles[rer],
-                                                           hsvs[rer], tresholds[rer], masks[rer],
-                                                           points[1], [points[0][0] + 70, points[0][1]])
-                        if move_breaker:
-                            break
-                        if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused':
-                            break
-                        move_breaker = check_and_move_tile(capture_window, vision_stun, config,
-                                                           [70, 70, rectangles[0][0], rectangles[0][1] + 70],
-                                                           needles[rer],
-                                                           hsvs[rer], tresholds[rer], masks[rer],
-                                                           points[2], [points[0][0], points[0][1] + 70])
-                        if move_breaker:
-                            break
-                        if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused':
-                            break
-                        move_breaker = check_and_move_tile(capture_window, vision_stun, config,
-                                                           [70, 70, rectangles[0][0] + 70, rectangles[0][1] + 70],
-                                                           needles[rer], hsvs[rer], tresholds[rer], masks[rer],
-                                                           points[3], [points[0][0] + 70, points[0][1] + 70])
-                        if move_breaker:
-                            break
-                        move_tile(config, points[4], [points[0][0], points[0][1]])
-                        if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused':
-                            break
-                    if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused':
-                        break
-                # debug the loop rate
-                print('FPS {}'.format(1 / (time() - outer_loop_time)))
-                outer_loop_time = time()
-                cv.waitKey(150)
-
-
-def check_and_move_tile(capture_win, visio, conf, rect, needl, hsv, tresh, mask, point_source, point_dest):
-    screenshot_p = capture_win.get_screenshot()
-    screenshot_p_w = screenshot_p.shape[1]
-    screenshot_p_h = screenshot_p.shape[0]
-    w = rect[0]
-    h = rect[1]
-    x = rect[2]
-    y = rect[3]
-    if h >= screenshot_p_h or w >= screenshot_p_w:
-        return True
-
-    screenshot_pos = screenshot_p[y:y + h, x:x + w]  # (w, h, x+w, y+h)
-    # processed_screenshot = visio.apply_hsv_filter(screenshot_pos, hsv)
-    # processed_needle = visio.apply_hsv_filter(needl, hsv)
-    result2 = cv.matchTemplate(screenshot_pos, needl, cv.TM_CCOEFF_NORMED)
-    _minVal2, _maxVal2, minLoc2, maxLoc2 = cv.minMaxLoc(result2, None)
-    # rectangles2 = visio.find(screenshot_pos, needl, tresh, 1, True, mask)
-    # output_by_area = vision_stun.draw_rectangles(screenshot_pos2, rectangles)
-    # cv.imshow("output_image_by_area", screenshot_pos)
-    # cv.waitKey(150)
-    # print("thresh in movecheck:" + str(_maxVal2))
-    if _maxVal2 <= 0.9:
-        move_tile(conf, point_source, point_dest)
-
-    return False
-
-
-def click_point(conf, x, y):
-    offset_left = conf.returnEquipmentWindowPos()[2]
-    offset_down = conf.returnEquipmentWindowPos()[3]
-    pydirectinput.moveTo(x + offset_left, y + offset_down)
-    pydirectinput.mouseDown()
-    w = random.randint(1, 50)
-    cv.waitKey(30 + w)
-    pydirectinput.mouseUp()
-
-
-def move_tile(conf, point_source, point_dest):
-    offset_left = conf.returnEquipmentWindowPos()[2]
-    offset_down = conf.returnEquipmentWindowPos()[3]
-    pydirectinput.moveTo(point_source[0] + offset_left, point_source[1] + offset_down)
-    pydirectinput.mouseDown()
-    w = random.randint(25, 50)
-    cv.waitKey(100 + w)
-    pydirectinput.moveTo(point_dest[0] + offset_left, point_dest[1] + offset_down)
-    pydirectinput.mouseUp()
-    cv.waitKey(400 + w)
-
-
-def find_emitter(emitter_to_use, vis, screen, layer):
-    if emitter_to_use == EMITTER_MUSH:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/mush_e_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/mush_e_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/mush_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/mush_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.98, 1, True, mask)
-    elif emitter_to_use == EMITTER_AMU:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/amu_e_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/amu_e_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/amu_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/amu_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-    elif emitter_to_use == EMITTER_MAIN:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/main_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/main_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/main_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/main_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-    elif emitter_to_use == EMITTER_SWORD:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/sword_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/sword_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/sword_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/sword_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.98, 1, True, mask)
-    elif emitter_to_use == EMITTER_STAFF:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/staff_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/staff_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/staff_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/staff_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.99, 1, True, mask)
-    elif emitter_to_use == EMITTER_RING:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/ring_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/ring_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/ring_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/ring_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-    elif emitter_to_use == EMITTER_WAND:
-        if layer == 0:
-            needle = cv.imread("equip/emitters/wand_e1_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/wand_e1_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.95, 1, True, mask)
-        else:
-            needle = cv.imread("equip/emitters/wand_e2_32.jpg", cv.IMREAD_UNCHANGED)
-            mask = cv.imread("equip/emitters/wand_e2_32-mask.png", cv.IMREAD_COLOR)
-            return vis.find(screen, needle, 0.96, 1, True, mask)
-
-
-def include_chests(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/chests/chest_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.95)
-    mask.append(cv.imread("equip/chests/chest_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/chests/chest_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.95)
-    mask.append(cv.imread("equip/chests/chest_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/chests/chest_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/chests/chest_3_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_books(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/books/book_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/books/book_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.9)
-    mask.append(cv.imread("equip/books/book_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.87)
-    mask.append(cv.imread("equip/books/book_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/books/book_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/books/book_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.9)
-    mask.append(cv.imread("equip/books/book_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/books/book_7_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/books/book_8_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/books/book_8_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_keys(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/keys/key_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/keys/key_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/keys/key_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/keys/key_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/keys/key_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/keys/key_3_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_pots(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/pots/pot_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.94)
-    mask.append(cv.imread("equip/pots/pot_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/pots/pot_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/pots/pot_6_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_bags(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/bags/bag_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.88)
-    mask.append(cv.imread("equip/bags/bag_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/bags/bag_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/bags/bag_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_coins(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/coins/coin_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/coins/coin_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/coins/coin_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/coins/coin_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/coins/coin_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/coins/coin_5_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_runes(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/runes/rune_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/runes/rune_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/runes/rune_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/runes/rune_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/runes/rune_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/runes/rune_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/runes/rune_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/runes/rune_4_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_mushs(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/mushrooms/mush_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/mushrooms/mush_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/mushrooms/mush_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_amus(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/amus/amu_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.9)
-    mask.append(cv.imread("equip/amus/amu_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.9)
-    mask.append(cv.imread("equip/amus/amu_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/amus/amu_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/amus/amu_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_swords(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/swords/sword_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/swords/sword_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/swords/sword_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_staffs(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/staffs/staff_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/staffs/staff_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/staffs/staff_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_rings(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/rings/ring_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.925)
-    mask.append(cv.imread("equip/rings/ring_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.94)
-    mask.append(cv.imread("equip/rings/ring_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/rings/ring_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/rings/ring_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/rings/ring_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.91)
-    mask.append(cv.imread("equip/rings/ring_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/rings/ring_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/rings/ring_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-def include_wands(needles, hsv, tresh, mask):
-    needles.append(cv.imread("equip/wands/wand_1_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_1_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_2_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_2_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_3_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_3_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_4_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_4_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_5_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_5_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_6_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_6_32-mask.png", cv.IMREAD_COLOR))
-
-    needles.append(cv.imread("equip/wands/wand_7_32.jpg", cv.IMREAD_UNCHANGED))
-    hsv.append(HSV_DEFAULT)
-    tresh.append(0.93)
-    mask.append(cv.imread("equip/wands/wand_7_32-mask.png", cv.IMREAD_COLOR))
-
-
-if __name__ == "__main__":
-    run()

equipment_overlay.py

@@ -1,121 +0,0 @@
-# Run tkinter code in another thread
-import threading
-import tkinter as tk
-from tkinter import ttk
-
-
-class EquipmentOverlay(threading.Thread):
-
-    def __init__(self, config):
-        threading.Thread.__init__(self)
-
-        self.run_mode = 'init'
-
-        self.root = tk.Tk
-
-        self.energy_use = tk.StringVar
-        self.spawn_use = tk.StringVar
-        self.emitter_use = tk.StringVar
-
-        self.EnergyLabel = tk.Label
-        self.EnergyEntry = tk.Entry
-        self.SpawnLabel = tk.Label
-        self.SpawnEntry = tk.Entry
-        self.EmitterLabel = tk.Label
-        self.Emitter_Box = ttk.Combobox
-
-        self.StartButton = tk.Button
-        self.StopButton = tk.Button
-        self.PauseButton = tk.Button
-        self.TkPosition = '135x115+60+600'
-
-        self.StatusLabel = tk.Label
-
-        # self.TkPosition = config.returnEnemyPlayerOverlayPos()
-        self.start()
-
-    def run(self):
-        self.root = tk.Tk()
-
-        self.energy_use = tk.StringVar(self.root, value='2000')
-        self.spawn_use = tk.StringVar(self.root, value='25')
-        self.emitter_use = tk.StringVar(self.root, value='multi')
-
-        self.EnergyLabel = tk.Label(self.root, text="Energy:", font=("Helvetica", 10, "bold"),
-                                    background="grey")
-        self.EnergyLabel.grid(row=0, column=0)
-        self.EnergyEntry = tk.Entry(self.root, textvariable=self.energy_use, font=("Helvetica", 10, "bold"), width='12')
-
-        self.EnergyEntry.grid(row=0, column=1, columnspan=2)
-
-        self.SpawnLabel = tk.Label(self.root, text="Spawn:", font=("Helvetica", 10, "bold"),
-                                   background="grey")
-        self.SpawnLabel.grid(row=1, column=0)
-        self.SpawnEntry = tk.Entry(self.root, textvariable=self.spawn_use, font=("Helvetica", 10, "bold"), width='12')
-
-        self.SpawnEntry.grid(row=1, column=1, columnspan=2)
-
-        self.EmitterLabel = tk.Label(self.root, text="Emitter:", font=("Helvetica", 10, "bold"),
-                                     background="grey")
-        self.EmitterLabel.grid(row=2, column=0)
-        self.Emitter_Box = ttk.Combobox(self.root, textvariable=self.emitter_use, font=("Helvetica", 8, "bold"),
-                                        width='10')
-        self.Emitter_Box['values'] = ('multi', 'main', 'mushroom', 'amulett', 'sword', 'staff', 'wand', 'ring')
-        self.Emitter_Box.grid(row=2, column=1, columnspan=2, sticky='w')
-
-        # self.EnemyLabel.pack()
-        self.ButtonFrame = tk.Frame(self.root)
-        self.StartButton = tk.Button(self.ButtonFrame, text="Start", command=self.start_button_callback, width='5')
-        self.StartButton.grid(row=0, column=0)
-        self.StopButton = tk.Button(self.ButtonFrame, text="Stop", command=self.stop_button_callback, width='5',
-                                    state=tk.DISABLED)
-        self.StopButton.grid(row=0, column=1)
-        self.PauseButton = tk.Button(self.ButtonFrame, text="Pause", command=self.pause_button_callback, width='5',
-                                     state=tk.DISABLED)
-        self.PauseButton.grid(row=0, column=2)
-        self.ButtonFrame.grid(row=3, column=0, columnspan=2)
-
-        self.StatusLabel = tk.Label(self.root, text="", font=("Helvetica", 10, "bold"),
-                                    background="grey")
-        self.StatusLabel.grid(row=4, column=0, columnspan=2)
-
-        # self.ClearButton.pack(side="top")
-        self.root.geometry(self.TkPosition)
-        self.root.overrideredirect(1)  # fenster ohne aussen rum :-)
-        #self.root.attributes('-alpha', 0.7)  # fenster transparent
-        self.root.attributes('-topmost', 1)  # fenster immer im vordergrund
-        # self.root.wm_attributes("-disabled", True)
-        self.root.configure(background='black')
-        self.root.mainloop()
-
-    def update_enemy_label(self, _text):
-        self.EnergyLabel.configure(text=_text)
-        # self.EnemyLabel.pack()
-
-    def start_button_callback(self):
-        self.StartButton.configure(state=tk.DISABLED)
-        self.StopButton.configure(state=tk.NORMAL)
-        self.PauseButton.configure(state=tk.NORMAL)
-        self.StatusLabel.configure(text='')
-        self.run_mode = 'started'
-
-        # self.EnemyLabel.pack()
-
-    def stop_button_callback(self):
-        self.StartButton.configure(state=tk.NORMAL)
-        self.StopButton.configure(state=tk.DISABLED)
-        self.PauseButton.configure(state=tk.DISABLED)
-        self.run_mode = 'stopped'
-
-    def pause_button_callback(self):
-        self.StartButton.configure(state=tk.NORMAL)
-        self.StopButton.configure(state=tk.NORMAL)
-        self.PauseButton.configure(state=tk.DISABLED)
-        self.run_mode = 'paused'
-
-    def get_run_mode(self):
-        return self.run_mode
-
-    def update_status_label(self, emitter, energy_to_go):
-        text = emitter + ": " + str(energy_to_go)
-        self.StatusLabel.configure(text=text)

farm.py

@@ -1,11 +1,7 @@
-import random
 import cv2 as cv
 import numpy as np
-import pydirectinput
-from window_capture import WindowCapture
-from vision import Vision
-from config_file import UserConfigs
 from utils import mse
+from game_base_class import GameBase
 
 GREEN = 1
 YELLOW = 2
@@ -30,74 +26,40 @@ CIBUTRANT = 24
 ARTISENT = 25
 
 
-class Field:
+class Farm(GameBase):
-    data_value_grid = []
-    data_coordinates = []
-    next_level = cv.imread("next_level.jpg", cv.IMREAD_COLOR)
-    next_level_x = cv.imread("next_level_x.jpg", cv.IMREAD_COLOR)
-    explosives = []
-    explosives.append(RAINBOW)
-    explosives.append(ARROW_RIGHT)
-    explosives.append(ARROW_DOWN)
-    explosives.append(BIGBOMB)
-    explosives.append(BOMB)
-    colors = []
-    colors.append(GREEN)
-    colors.append(YELLOW)
-    colors.append(BLUE)
-    colors.append(RED)
-    colors.append(PINK)
-    colors.append(MAGINENT)
-    colors.append(CHEMTRANT)
-    colors.append(TENESENT)
-    colors.append(CIBUTRANT)
 
+    def __init__(self, overlay):
+        super().__init__(overlay)
 
-    def __init__(self):
+        self.farm_reset_board = cv.imread("control_elements/farm_reset_button.jpg", cv.IMREAD_COLOR)
-        self.data_value_grid = np.zeros((8, 14), dtype=int)
-        self.data_coordinates = np.zeros((8, 14), dtype=object)
-        self.observation = np.zeros((8, 14), dtype=int)
 
-        # 230 to 2110 = 1883 / 14 = 134.5
+        self.colors.append(PINK)
-        # 60 to 1130 = 1076 / 8 =  134.5
-        dim = 134.5
-        for e in range(0, 8, 1):
-            for i in range(0, 14, 1):
-                self.data_coordinates[e][i] = [i * dim, e * dim, dim, dim]
 
-        # initialize the user-class
+        self.fill_data_coordinates()
-        self.config = UserConfigs()
 
-        # initialize the StunWindowCapture class
+        self.needles = {GREEN: cv.imread("farm/green.jpg", cv.IMREAD_COLOR),
-        self.capture_window = WindowCapture(None, None, self.config)
+                        YELLOW: cv.imread("farm/yellow.jpg", cv.IMREAD_COLOR),
-        # initialize the StunVision class
+                        BLUE: cv.imread("farm/blue.jpg", cv.IMREAD_COLOR),
-        self.vision_stun = Vision()
+                        RED: cv.imread("farm/red.jpg", cv.IMREAD_COLOR),
-
+                        PINK: cv.imread("farm/pink.jpg", cv.IMREAD_COLOR),
-        self.needles = {GREEN: cv.imread("green.jpg", cv.IMREAD_COLOR),
+                        RAINBOW: cv.imread("farm/rainbow.jpg", cv.IMREAD_COLOR),
-                        YELLOW: cv.imread("yellow.jpg", cv.IMREAD_COLOR),
+                        BIGBOMB: cv.imread("farm/bigbomb.jpg", cv.IMREAD_COLOR),
-                        BLUE: cv.imread("blue.jpg", cv.IMREAD_COLOR),
+                        BOMB: cv.imread("farm/bomb.jpg", cv.IMREAD_COLOR),
-                        RED: cv.imread("red.jpg", cv.IMREAD_COLOR),
+                        ARROW_DOWN: cv.imread("farm/arrow_down.jpg", cv.IMREAD_COLOR),
-                        PINK: cv.imread("pink.jpg", cv.IMREAD_COLOR),
+                        ARROW_RIGHT: cv.imread("farm/arrow_right.jpg", cv.IMREAD_COLOR),
-                        RAINBOW: cv.imread("rainbow.jpg", cv.IMREAD_COLOR),
+                        ROCK_1: cv.imread("farm/rock1.jpg", cv.IMREAD_COLOR),
-                        BIGBOMB: cv.imread("bigbomb.jpg", cv.IMREAD_COLOR),
+                        ROCK_2: cv.imread("farm/rock2.jpg", cv.IMREAD_COLOR),
-                        BOMB: cv.imread("bomb.jpg", cv.IMREAD_COLOR),
+                        ROCK_3: cv.imread("farm/rock3.jpg", cv.IMREAD_COLOR),
-                        ARROW_DOWN: cv.imread("arrow_down.jpg", cv.IMREAD_COLOR),
+                        BURGER: cv.imread("farm/burger.jpg", cv.IMREAD_COLOR),
-                        ARROW_RIGHT: cv.imread("arrow_right.jpg", cv.IMREAD_COLOR),
+                        GOLDBAR: cv.imread("farm/burger.jpg", cv.IMREAD_COLOR),
-                        ROCK_1: cv.imread("rock1.jpg", cv.IMREAD_COLOR),
+                        PAB1: cv.imread("farm/pab1.jpg", cv.IMREAD_COLOR),
-                        ROCK_2: cv.imread("rock2.jpg", cv.IMREAD_COLOR),
+                        MAGINENT: cv.imread("farm/maginent.jpg", cv.IMREAD_COLOR),
-                        ROCK_3: cv.imread("rock3.jpg", cv.IMREAD_COLOR),
+                        CHEMTRANT: cv.imread("farm/chemtrant.jpg", cv.IMREAD_COLOR),
-                        BURGER: cv.imread("burger.jpg", cv.IMREAD_COLOR),
+                        TENESENT: cv.imread("farm/tenesent.jpg", cv.IMREAD_COLOR),
-                        GOLDBAR: cv.imread("burger.jpg", cv.IMREAD_COLOR),
+                        CIBUTRANT: cv.imread("farm/cibutrant.jpg", cv.IMREAD_COLOR),
-                        PAB1: cv.imread("pab1.jpg", cv.IMREAD_COLOR),
+                        ARTISENT: cv.imread("farm/artisent.jpg", cv.IMREAD_COLOR)
-                        MAGINENT: cv.imread("maginent.jpg", cv.IMREAD_COLOR),
-                        CHEMTRANT: cv.imread("chemtrant.jpg", cv.IMREAD_COLOR),
-                        TENESENT: cv.imread("tenesent.jpg", cv.IMREAD_COLOR),
-                        CIBUTRANT: cv.imread("cibutrant.jpg", cv.IMREAD_COLOR)
                         }
 
-    def reset(self):
-        self.observation = []
-
     def assess_playfield_and_make_move(self):
 
         new_observation, new_screenshot = self.get_current_board_state()
@@ -106,83 +68,65 @@ class Field:
         # last board state is same as actual
         if mse(new_observation, self.observation) == 0.0:
             # no movement detected -> blow explosives or reset
-            self.detonate_explosive_when_stuck(new_observation)
+
-            cv.waitKey(500)
+            self.reset_counter += 1
+            if self.reset_counter == 1:
+                pass
+            elif self.reset_counter == 2:
+                if self.detonate_explosive_when_stuck(new_observation):
+                    new_observation, new_screenshot = self.get_current_board_state()
+                    if mse(new_observation, self.observation) != 0.0:
+                        self.reset_counter = 0
+                return
+            elif self.reset_counter >= 3:
+                screenshot = self.capture_window.get_screenshot()
+                if self.check_for_button_and_execute(screenshot, self.farm_reset_board):
+                    cv.waitKey(500)
+                screenshot = self.capture_window.get_screenshot()
+                if self.check_for_button_and_execute(screenshot, self.reset_confirm):
+                    cv.waitKey(500)
+
+                self.reset_counter = 0
+                return
+            else:
+                return
 
         self.find_patterns_and_valid_moves(new_observation)
         self.observation = new_observation
         return new_observation
 
-    def move_to(self, x, y):
-        point_src = (1113, 598)
-        pydirectinput.moveTo(point_src[0], point_src[1])
-        pydirectinput.mouseDown()
-        w = random.randint(1, 100)
-        cv.waitKey(150 + w)
-        pydirectinput.moveTo(x, y)
-        pydirectinput.mouseUp()
-        cv.waitKey(500 + w)
-
-    def change_value(self, x, y, val):
-        self.data_value_grid[x][y] = val
-
-    def pointInRect(self, point):
-        for e in range(0, 8, 1):
-            for i in range(0, 14, 1):
-                x1, y1, w, h = self.data_coordinates[e][i]
-                x2, y2 = x1 + w, y1 + h
-                x, y = point
-                if (x1 < x and x < x2):
-                    if (y1 < y and y < y2):
-                        return e, i
-        return None, None
-
-    def check_for_next_level(self, screen, needle):
-        offset_left = 230
-        offset_down = 58
-        rectangles = self.vision_stun.find(screen, needle, 0.70, 1)
-        if len(rectangles) == 0:
-            return False
-        point = self.vision_stun.get_click_points(rectangles)[0]
-        self.dig_point(point[0]+ offset_left, point[1] + offset_down, 500)
-        return True
-
     def get_current_board_state(self):
-        try:
+        # get an updated image of the game
-            # get an updated image of the game
+        screenshot = self.capture_window.get_screenshot()
+        # screenshot = cv.imread("field_farm.jpg")
+        screenshot = screenshot[190:1230, 260:2090]  # 1883,1076
+        # gray = cv.cvtColor(screenshot, cv.COLOR_BGR2GRAY)
+        # thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
+        if self.check_for_next_level(screenshot, self.next_level):
+            cv.waitKey(500)
             screenshot = self.capture_window.get_screenshot()
-            #screenshot = cv.imread("field_farm.jpg")
+            screenshot = screenshot[190:1230, 260:2090]
-            screenshot = screenshot[58:1134, 230:2113]  # 1883,1076
+        if self.check_for_next_level(screenshot, self.next_level_x):
-            # gray = cv.cvtColor(screenshot, cv.COLOR_BGR2GRAY)
+            cv.waitKey(500)
-            # thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
+            screenshot = self.capture_window.get_screenshot()
-            if self.check_for_next_level(screenshot, self.next_level):
+            screenshot = screenshot[190:1230, 260:2090]
-                cv.waitKey(500)
-                screenshot = self.capture_window.get_screenshot()
-                screenshot = screenshot[58:1134, 230:2113]
-            if self.check_for_next_level(screenshot, self.next_level_x):
-                cv.waitKey(500)
-                screenshot = self.capture_window.get_screenshot()
-                screenshot = screenshot[58:1134, 230:2113]
 
-        except:
+        #cv.imshow("screenshot", screenshot)
-            self.capture_window.release()
+        #cv.waitKey(150)
-            print("Game window not available - shutting down application")
+        #return
-            return None
+        #continue
-        # cv.imshow("screenshot", screenshot)
-        # cv.waitKey(150)
-        # continue
         data_coords = np.zeros((8, 14), dtype=object)
-        # field = Field()
+        # field = Pickaxe_Field()
         for needle_key in self.needles.keys():
             # gray_needle = cv.cvtColor(self.needles[needle_key], cv.COLOR_BGR2GRAY)
             # thresh_needle = cv.threshold(gray_needle, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
-            rectangles = self.vision_stun.find(screenshot, self.needles[needle_key], 0.70, 56)
+            rectangles = self.vision_stun.find(screenshot, self.needles[needle_key], 0.74, 56)
             if len(rectangles) == 0:
                 continue
             points = self.vision_stun.get_click_points(rectangles)
 
             for point in points:
-                x, y = self.pointInRect(point)
+                x, y = self.point_in_rect(point)
                 if x is not None and y is not None:
                     data_coords[x][y] = int(needle_key)
                     # self.change_value(x, y, int(needle_key))
@@ -198,14 +142,22 @@ class Field:
             for i in range(0, 14, 1):
                 if self.check_explosives(state, e, i):
                     return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
 
         for e in range(0, 8, 1):
             for i in range(0, 14, 1):
                 for color in self.colors:
-                    if self.check_5_horizontal(state, e, i, color):
+                    if self.check_5s(state, e, i, color):
                         return
-                    if self.check_5_vertical(state, e, i, color):
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
                         return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
 
         for e in range(0, 8, 1):
             for i in range(0, 14, 1):
@@ -216,6 +168,12 @@ class Field:
                         return
                     if self.check_3_with_gap(state, e, i, color):
                         return
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
 
     def detonate_explosive_when_stuck(self, state):
         for e in range(0, 8, 1):
@@ -226,95 +184,50 @@ class Field:
                         if self.local_pos_checks(state, e, i, 1, 0, self.colors):
                             src_pt = self.get_click_point(self.data_coordinates[e + 1, i])
                             self.move_tile(src_pt, dest_pt)
+                            return True
                         elif self.local_pos_checks(state, e, i, 0, 1, self.colors):
                             src_pt = self.get_click_point(self.data_coordinates[e, i + 1])
                             self.move_tile(src_pt, dest_pt)
+                            return True
                         elif self.local_pos_checks(state, e, i, -1, 0, self.colors):
                             src_pt = self.get_click_point(self.data_coordinates[e - 1, i])
                             self.move_tile(src_pt, dest_pt)
+                            return True
                         elif self.local_pos_checks(state, e, i, 0, -1, self.colors):
                             src_pt = self.get_click_point(self.data_coordinates[e, i - 1])
                             self.move_tile(src_pt, dest_pt)
+                            return True
                         else:
                             continue
-                        return
-
-    def check_explosives(self, state, e, i):
-        for explosive in self.explosives:
-            if self.local_pos_check(state, e, i, 0, 0, explosive):
-                dest_pt = self.get_click_point(self.data_coordinates[e, i])
-                if self.local_pos_checks(state, e, i, 1, 0, self.explosives):
-                    src_pt = self.get_click_point(self.data_coordinates[e + 1, i])
-                    self.move_tile(src_pt, dest_pt)
-                elif self.local_pos_checks(state, e, i, 0, 1, self.explosives):
-                    src_pt = self.get_click_point(self.data_coordinates[e, i + 1])
-                    self.move_tile(src_pt, dest_pt)
-                elif self.local_pos_checks(state, e, i, -1, 0, self.explosives):
-                    src_pt = self.get_click_point(self.data_coordinates[e - 1, i])
-                    self.move_tile(src_pt, dest_pt)
-                elif self.local_pos_checks(state, e, i, 0, -1, self.explosives):
-                    src_pt = self.get_click_point(self.data_coordinates[e, i - 1])
-                    self.move_tile(src_pt, dest_pt)
-                else:
-                    continue
-                return True
-            else:
-                continue
         return False
 
-    def local_pos_check(self, state, e, i, e_check, i_check, needle):
+    def check_5s(self, state, e, i, color):
-        if e + e_check >= 0 and e + e_check <=7 and i + i_check >= 0 and i + i_check <=13:
-            if state[e + e_check, i + i_check] == needle:
-                return True
-            else:
-                return False
-
-    def local_pos_checks(self, state, e, i, e_check, i_check, needles):
-        if e + e_check >= 0 and e + e_check <=7 and i + i_check >= 0 and i + i_check <=13:
-            for needle in needles:
-                if state[e + e_check, i + i_check] == needle:
-                    return True
-                else:
-                    continue
-        return False
-
-    def check_5_horizontal(self, state, e, i, color):
         try:
             #
-            if state[e, i] == color and state[e, i + 1] == color and state[e, i + 3] == color and state[
+            if state[e, i] == color and state[e + 1, i] == color and state[e + 3, i] == color and state[e + 4, i] == color:
-                e, i + 4] == color:
+                if state[e + 2, i] in self.colors:
-                if state[e, i + 2] <= 0 or state[e, i + 2] >= 6:
+                    if self.is_direction_in_bounce_and_same_color(state, (e + 2, i - 1), color):
-                    return False
-                #
-                if e - 1 >= 0 and i + 2 <= 13:
-                    if state[e - 1, i + 2] == color:
-                        return True
-            return False
-        except:
-            return False
-
-    def check_5_vertical(self, state, e, i, color):
-        try:
-            #
-            if state[e, i] == color and state[e + 1, i] == color and state[e + 3, i] == color and state[
-                e + 4, i] == color:
-                if state[e + 2, i] <= 0 or state[e + 2, i] >= 6:
-                    return False
-                # third left upper
-                if e + 2 <= 7 and i - 1 >= 0:
-                    if state[e + 2, i - 1] == color:
-                        print("upper left", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e + 2, i - 1])
                         dest_pt = self.get_click_point(self.data_coordinates[e + 2, i])
                         self.move_tile(src_pt, dest_pt)
                         return True
-                if e + 2 <= 7 and i + 1 <= 13:
+                    if self.is_direction_in_bounce_and_same_color(state, (e + 2, i + 1), color):
-                    if state[e + 2, i + 1] == color:
-                        print("upper left", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e + 2, i + 1])
                         dest_pt = self.get_click_point(self.data_coordinates[e + 2, i])
                         self.move_tile(src_pt, dest_pt)
                         return True
+            elif state[e, i] == color and state[e, i + 1] == color and state[e, i + 3] == color and state[e, i + 4] == color:
+                if state[e, i + 2] in self.colors:
+                    if self.is_direction_in_bounce_and_same_color(state, (e + 1, i +2), color):
+                        src_pt = self.get_click_point(self.data_coordinates[e + 1, i + 2])
+                        dest_pt = self.get_click_point(self.data_coordinates[e, i + 2])
+                        self.move_tile(src_pt, dest_pt)
+                        return True
+                    if self.is_direction_in_bounce_and_same_color(state, (e - 1, i + 2), color):
+                        src_pt = self.get_click_point(self.data_coordinates[e - 1,  i + 2])
+                        dest_pt = self.get_click_point(self.data_coordinates[e,  i + 2])
+                        self.move_tile(src_pt, dest_pt)
+                        return True
             return False
         except:
             return False
@@ -326,7 +239,7 @@ class Field:
                 if state[e, i] == color and state[e, i + 2] == color:
                     # third upper
                     if e - 1 >= 0 and i + 1 <= 13:
-                        #if state[e - 1, i - 1] == color and (state[e, i - 1] >= 1 and state[e, i - 1] <= 5):
+                        # if state[e - 1, i - 1] == color and (state[e, i - 1] >= 1 and state[e, i - 1] <= 5):
                         if state[e - 1, i + 1] == color and (state[e, i + 1] in self.colors):
                             src_pt = self.get_click_point(self.data_coordinates[e - 1, i + 1])
                             dest_pt = self.get_click_point(self.data_coordinates[e, i + 1])
@@ -343,7 +256,7 @@ class Field:
                 if state[e, i] == color and state[e + 2, i] == color:
                     # third upper
                     if e + 1 >= 0 and i + 1 <= 13:
-                        #if state[e - 1, i - 1] == color and (state[e, i - 1] >= 1 and state[e, i - 1] <= 5):
+                        # if state[e - 1, i - 1] == color and (state[e, i - 1] >= 1 and state[e, i - 1] <= 5):
                         if state[e + 1, i + 1] == color and (state[e + 1, i] in self.colors):
                             src_pt = self.get_click_point(self.data_coordinates[e + 1, i + 1])
                             dest_pt = self.get_click_point(self.data_coordinates[e + 1, i])
@@ -366,7 +279,7 @@ class Field:
                 # third left upper
                 if e - 1 >= 0 and i - 1 >= 0:
                     if state[e - 1, i - 1] == color and (state[e, i - 1] in self.colors):
-                        print("upper left", color, e, i)
+                        # print("upper left", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e - 1, i - 1])
                         dest_pt = self.get_click_point(self.data_coordinates[e, i - 1])
                         self.move_tile(src_pt, dest_pt)
@@ -374,7 +287,7 @@ class Field:
                 # third left lower
                 if e + 1 <= 7 and i - 1 >= 0:
                     if state[e + 1, i - 1] == color and (state[e, i - 1] in self.colors):
-                        print("lower left", color, e, i)
+                        # print("lower left", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e + 1, i - 1])
                         dest_pt = self.get_click_point(self.data_coordinates[e, i - 1])
                         self.move_tile(src_pt, dest_pt)
@@ -382,7 +295,7 @@ class Field:
                 # third left with gap
                 if i - 2 >= 0:
                     if state[e, i - 2] == color and (state[e, i - 1] in self.colors):
-                        print("left gap ", color, e, i)
+                        # print("left gap ", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e, i - 2])
                         dest_pt = self.get_click_point(self.data_coordinates[e, i - 1])
                         self.move_tile(src_pt, dest_pt)
@@ -390,7 +303,7 @@ class Field:
                 # third right upper
                 if e - 1 >= 0 and i + 2 <= 13:
                     if state[e - 1, i + 2] == color and (state[e, i + 2] in self.colors):
-                        print("upper right", color, e, i)
+                        # print("upper right", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e - 1, i + 2])
                         dest_pt = self.get_click_point(self.data_coordinates[e, i + 2])
                         self.move_tile(src_pt, dest_pt)
@@ -398,7 +311,7 @@ class Field:
                 # third right lower
                 if e + 1 <= 7 and i + 2 <= 13:
                     if state[e + 1, i + 2] == color and (state[e, i + 2] in self.colors):
-                        print("upper lower", color, e, i)
+                        # print("upper lower", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e + 1, i + 2])
                         dest_pt = self.get_click_point(self.data_coordinates[e, i + 2])
                         self.move_tile(src_pt, dest_pt)
@@ -407,7 +320,7 @@ class Field:
                 # third right with gap
                 if i + 3 <= 13:
                     if state[e, i + 3] == color and (state[e, i + 2] in self.colors):
-                        print("right gap ", color, e, i)
+                        # print("right gap ", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e, i + 3])
                         dest_pt = self.get_click_point(self.data_coordinates[e, i + 2])
                         self.move_tile(src_pt, dest_pt)
@@ -422,7 +335,7 @@ class Field:
                 # third left upper
                 if e - 1 >= 0 and i - 1 >= 0:
                     if state[e - 1, i - 1] == color and (state[e - 1, i] in self.colors):
-                        print("upper left", color, e, i)
+                        # print("upper left", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e - 1, i - 1])
                         dest_pt = self.get_click_point(self.data_coordinates[e - 1, i])
                         self.move_tile(src_pt, dest_pt)
@@ -430,7 +343,7 @@ class Field:
                 # third left lower
                 if e + 2 <= 7 and i - 1 >= 0:
                     if state[e + 2, i - 1] == color and (state[e + 2, i] in self.colors):
-                        print("lower left", color, e, i)
+                        # print("lower left", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e + 2, i - 1])
                         dest_pt = self.get_click_point(self.data_coordinates[e + 2, i])
                         self.move_tile(src_pt, dest_pt)
@@ -438,7 +351,7 @@ class Field:
                 # third right upper
                 if e - 1 >= 0 and i + 1 <= 13:
                     if state[e - 1, i + 1] == color and (state[e - 1, i] in self.colors):
-                        print("upper right", color, e, i)
+                        # print("upper right", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e - 1, i + 1])
                         dest_pt = self.get_click_point(self.data_coordinates[e - 1, i])
                         self.move_tile(src_pt, dest_pt)
@@ -446,7 +359,7 @@ class Field:
                 # third right lower
                 if e + 2 <= 7 and i + 1 <= 13:
                     if state[e + 2, i + 1] == color and (state[e + 2, i] in self.colors):
-                        print("upper lower", color, e, i)
+                        # print("upper lower", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e + 2, i + 1])
                         dest_pt = self.get_click_point(self.data_coordinates[e + 2, i])
                         self.move_tile(src_pt, dest_pt)
@@ -454,7 +367,7 @@ class Field:
                 # third upper with gap
                 if e - 2 >= 0:
                     if state[e - 2, i] == color and (state[e - 1, i] in self.colors):
-                        print("upper gap ", color, e, i)
+                        # print("upper gap ", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e - 2, i])
                         dest_pt = self.get_click_point(self.data_coordinates[e - 1, i])
                         self.move_tile(src_pt, dest_pt)
@@ -462,54 +375,10 @@ class Field:
                 # third lower with gap
                 if e + 3 <= 7:
                     if state[e + 3, i] == color and (state[e + 2, i] in self.colors):
-                        print("lower gap ", color, e, i)
+                        # print("lower gap ", color, e, i)
                         src_pt = self.get_click_point(self.data_coordinates[e + 3, i])
                         dest_pt = self.get_click_point(self.data_coordinates[e + 2, i])
                         self.move_tile(src_pt, dest_pt)
                         return True
         except:
             return False
-
-    def move_tile(self, point_source, point_dest):
-        offset_left = 230
-        offset_down = 58
-        pydirectinput.moveTo(point_source[0] + offset_left, point_source[1] + offset_down)
-        # pydirectinput.moveTo(0,0)
-        pydirectinput.mouseDown()
-        w = random.randint(25, 50)
-        cv.waitKey(100 + w)
-        pydirectinput.moveTo(point_dest[0] + offset_left, point_dest[1] + offset_down)
-        pydirectinput.mouseUp()
-        cv.waitKey(400 + w)
-
-    def check_for_button_and_click_it(self, button_url):
-        screenshot = self.capture_window.get_screenshot()
-        # gray = cv.cvtColor(screenshot, cv.COLOR_BGR2GRAY)
-        # thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
-        # gray_needle = cv.cvtColor(cv.imread(button_url, cv.IMREAD_UNCHANGED), cv.COLOR_BGR2GRAY)
-        # thresh_needle = cv.threshold(gray_needle, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
-        needle = cv.imread(button_url, cv.IMREAD_UNCHANGED)
-        # rectangles = self.vision_stun.find(thresh, thresh_needle, 0.4, 1)
-        rectangles = self.vision_stun.find(screenshot, needle, 0.7, 1)
-
-        if len(rectangles) == 1:
-            pointis = self.vision_stun.get_click_points(rectangles)
-            for pointi in pointis:
-                self.dig_point(pointi[0], pointi[1], 150)
-
-    def dig_point(self, point1, point2, dig_time):
-        pydirectinput.moveTo(point1, point2)
-        cv.waitKey(dig_time)
-        pydirectinput.mouseDown()
-        w = random.randint(50, 100)
-        cv.waitKey(w)
-        pydirectinput.mouseUp()
-
-    def get_click_point(self, rectangle):
-        # Loop over all the rectangles
-        x, y, w, h = rectangle
-        # Determine the center position
-        center_x = x + int(w / 2)
-        center_y = y + int(h / 2)
-        # Save the points
-        return int(center_x), int(center_y)

farm/main_farm.py

@@ -1,39 +0,0 @@
-from Field_Representation import Field
-from time import time
-import cv2 as cv
-import keyboard
-
-def run():
-    field = Field()
-    loop_time_p = time()
-    pause = True
-
-    while True:
-        if keyboard.is_pressed('p') == True:
-            pause = True
-            print('q pressed')
-        elif keyboard.is_pressed('o') == True:
-            pause = False
-            print('o pressed')
-
-        if pause:
-            # cv.waitKey(500)
-            if (time() - loop_time_p) >= 5:
-                loop_time_p = time()
-                print("pausing")
-            continue
-
-
-        #cords, screenshot = field.get_current_board_state()
-        cords = field.assess_playfield_and_make_move()
-        print(cords)
-        cv.waitKey(1000)
-
-
-    #cv.imshow("screenshot", screenshot)
-    #cv.waitKey(150)
-    #print(cords)
-
-
-if __name__ == "__main__":
-    run()

field.py

@@ -0,0 +1,213 @@
+#!/usr/bin/python
+from copy import copy
+
+from tetromino import Tetromino
+
+class Field():
+
+    WIDTH = 20
+    HEIGHT = 20
+
+    def __init__(self, state=None):
+        if state:
+            self.state = state
+        else:
+            self.state = [[' ' for cols in range(Field.WIDTH)]
+                          for rows in range(Field.HEIGHT)]
+        self.cleared_rows = 1
+
+    def __str__(self):
+        BAR = '   ' + '-' * (Field.WIDTH * 2 + 1) + '\n    ' + \
+            ' '.join(map(str, range(Field.WIDTH))) + '\n'
+        return BAR + '\n'.join([
+            '{:2d} |'.format(i) + ' '.join(row) + '|'
+                for i, row in enumerate(self.state)]) + '\n' + BAR
+
+    @staticmethod
+    def matrixflip(m, d):
+        tempm = m.copy()
+        if d == 'h':
+            for i in range(0, len(tempm), 1):
+                tempm[i].reverse()
+        elif d == 'v':
+            tempm.reverse()
+        return (tempm)
+
+    @staticmethod
+    def rotate_90_degree_anticlckwise(matrix):
+        new_matrix = []
+        for i in range(len(matrix[0]), 0, -1):
+            new_matrix.append(list(map(lambda x: x[i - 1], matrix)))
+
+        return new_matrix
+
+    @staticmethod
+    def rotate_90_degree_clckwise(matrix):
+        new_matrix = []
+        for i in range(len(matrix[0])):
+            li = list(map(lambda x: x[i], matrix))
+            li.reverse()
+            new_matrix.append(li)
+
+        return new_matrix
+
+    def reset_field(self):
+        self.state = [[' ' for cols in range(Field.WIDTH)]
+                      for rows in range(Field.HEIGHT)]
+
+    def reset_half_field(self):
+        for row in range(int(self.HEIGHT/2)):
+            self.state[row] = [' ' for cols in range(Field.WIDTH)]
+
+    def rotate_state(self):
+        self.state = Field.rotate_90_degree_anticlckwise(self.state)
+
+
+    def get_line_count(self):
+        return self.cleared_rows
+
+    def _test_tetromino(self, tetromino, row, column):
+        """
+        Tests to see if a tetromino can be placed at the specified row and
+        column. It performs the test with the bottom left corner of the
+        tetromino at the specified row and column.
+        """
+        assert column >= 0
+        assert column + tetromino.width() <= Field.WIDTH
+        assert row - tetromino.height() + 1 >= 0
+        assert row < Field.HEIGHT
+        for ti, si in list(enumerate(range(row - tetromino.height() + 1,
+                                           row + 1)))[::-1]:
+            for tj, sj in enumerate(range(column, column + tetromino.width())):
+                if tetromino[ti][tj] != ' ' and self.state[si][sj] != ' ':
+                    return False
+        return True
+
+    def _place_tetromino(self, tetromino, row, column):
+        """
+        Place a tetromino at the specified row and column.
+        The bottom left corner of the tetromino will be placed at the specified
+        row and column. This function does not perform checks and will overwrite
+        filled spaces in the field.
+        """
+        assert column >= 0
+        assert column + tetromino.width() <= Field.WIDTH
+        assert row - tetromino.height() + 1 >= 0
+        assert row < Field.HEIGHT
+        for ti, si in list(enumerate(range(row - tetromino.height() + 1,
+                                           row + 1)))[::-1]:
+            for tj, sj in enumerate(range(column, column + tetromino.width())):
+                if tetromino[ti][tj] != ' ':
+                    self.state[si][sj] = tetromino[ti][tj]
+
+    def _get_tetromino_drop_row(self, tetromino, column):
+        """
+        Given a tetromino and a column, return the row that the tetromino
+        would end up in if it were dropped in that column.
+        Assumes the leftmost column of the tetromino will be aligned with the
+        specified column.
+        """
+        assert isinstance(tetromino, Tetromino)
+        assert column >= 0
+        assert column + tetromino.width() <= Field.WIDTH
+        last_fit = -1
+        for row in range(tetromino.height(), Field.HEIGHT):
+            if self._test_tetromino(tetromino, row, column):
+                last_fit = row
+            else:
+                return last_fit
+        return last_fit
+
+    def _line_clear(self):
+        """
+        Checks and removes all filled lines.
+        """
+        self.state = list(filter(lambda row: row.count(' ') != 0, self.state))
+        while len(self.state) < Field.HEIGHT:
+            self.state.insert(0, [' ' for col in range(Field.WIDTH)])
+            self.cleared_rows = self.cleared_rows + 1
+            print("cleared rows: ", self.cleared_rows)
+
+    def copy(self):
+        """
+        Returns a shallow copy of the field.
+        """
+        return Field([row[:] for row in self.state])
+
+    def drop(self, tetromino, column):
+        """
+        Drops a tetromino in the specified column.
+        The leftmost column of the tetromino will be aligned with the specified
+        column.
+        Returns the row it was dropped in for computations.
+        """
+        assert isinstance(tetromino, Tetromino)
+        assert column >= 0
+        assert column + tetromino.width() <= Field.WIDTH
+        row = self._get_tetromino_drop_row(tetromino, column)
+        assert row != -1
+        self._place_tetromino(tetromino, row, column)
+        self._line_clear()
+        return row
+
+
+
+    def check_crucial_pos_to_be_free(self):
+        if self.state[19][9] == ' ' and self.state[19][10] == ' ' and self.state[18][9] == ' ' and self.state[18][10] == ' ':
+            return True
+        return False
+
+    def predict_gaps_in_next_rotation(self):
+        tmp_state = copy(self.state)
+        tmp_state = Field.rotate_90_degree_anticlckwise(tmp_state)
+        for row in range(int(self.HEIGHT/2)):
+            tmp_state[row] = [' ' for cols in range(Field.WIDTH)]
+        return sum(
+            ["".join([row[col] for row in tmp_state]).lstrip().count(' ')
+             for col in range(Field.WIDTH)])
+
+
+    def count_gaps(self):
+        """
+        Check each column one by one to make sure there are no gaps in the
+        column.
+        """
+        return sum(
+            ["".join([row[col] for row in self.state]).lstrip().count(' ')
+             for col in range(Field.WIDTH)])
+
+    def height(self):
+        """
+        Returns the height on the field of the highest placed tetromino on the
+        field.
+        """
+        for i, row in enumerate(self.state):
+            if ''.join(row).strip():
+                return Field.HEIGHT - i
+
+if __name__ == '__main__':
+    import sys
+    f = Field()
+    if len(sys.argv) > 1 and sys.argv[1] == 'sim':
+        from optimizer import Optimizer
+        i = input()
+        while i != 'q':
+            t = Tetromino.create(i)
+            opt = Optimizer.get_optimal_drop(f, t)
+            t.rotate(opt['orientation'])
+            f.drop(t, opt['column'])
+            print(f)
+            i = input()
+    t = Tetromino.JTetromino().rotate_right()
+    print(t)
+    f.drop(t, 0)
+    print(f)
+    # f.drop(Tetromino.LTetromino(), 2)
+    # print(f)
+    # f.drop(Tetromino.JTetromino().rotate_left(), 5)
+    # print(f)
+    # t = Tetromino.LTetromino().flip()
+    # f.drop(t, 0)
+    # f.drop(Tetromino.TTetromino().flip(), 0)
+    # f.drop(Tetromino.JTetromino(), 4)
+    # print(f)

flappy.py

@@ -0,0 +1,49 @@
+import cv2 as cv
+import pydirectinput
+from game_base_class import GameBase
+from flappy_pos_discovery_thread import FlappyPosDiscovery
+from keyboard_thread import KeyboardEvent
+
+class Flappy(GameBase):
+
+    def __init__(self, overlay):
+        super().__init__(overlay)
+
+        self.litris_reset_board = cv.imread("control_elements/sodoku_reset_button.jpg", cv.IMREAD_COLOR)
+
+        self.flappy_pos_disc = FlappyPosDiscovery()
+        self.keyboard_listener = KeyboardEvent()
+
+    def assess_playfield_and_make_move(self):
+        #last_letter_received = time()
+
+        while True:
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+            wait_timer = 380 + self.keyboard_listener.offset_value
+            self.click()
+            cv.waitKey(wait_timer)
+            '''
+            if self.flappy_pos_disc.next_gate_height[0] is not 0:
+                offset = (self.flappy_pos_disc.next_gate_height[0] + 120) - self.flappy_pos_disc.get_actual_pet_height()
+                if offset > 50:
+                    self.click()
+            cv.waitKey(int(wait_timer -100))
+            print("pet_pos: ", self.flappy_pos_disc.get_actual_pet_height())
+
+            if self.flappy_pos_disc.next_gate_height[0] is not 0:
+                offset = (self.flappy_pos_disc.next_gate_height[0] + 120) - self.flappy_pos_disc.current_pet_height
+                if offset > 50:
+                    offset = 50
+                elif offset < -50:
+                    offset = -50
+                print(offset)
+                wait_timer = 380 + offset
+                print(wait_timer)
+                print("pet_pos: ", self.flappy_pos_disc.current_pet_height)
+                print("next gate: ", self.flappy_pos_disc.next_gate_height[0] + 120) '''
+
+    def click(self):
+        pydirectinput.mouseDown()
+        cv.waitKey(50)
+        pydirectinput.mouseUp()

flappy_pos_discovery_thread.py

@@ -0,0 +1,83 @@
+import threading
+import cv2 as cv
+from window_capture import WindowCapture
+from vision import Vision
+from config_file import UserConfigs
+
+class FlappyPosDiscovery(threading.Thread):
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+
+        self.config = UserConfigs()
+        self.capture_window = WindowCapture(None, None, self.config)
+        self.vision_stun = Vision()
+
+        self.needle_f = self.scale_picture(cv.imread("flappy/flappy.jpg"), 50)
+        self.mask_f = self.scale_picture(cv.imread("flappy/flappy-mask.png"), 50)
+
+        self.needle_g = self.scale_picture(cv.imread("flappy/gate.jpg"), 50)
+        self.mask_g = self.scale_picture(cv.imread("flappy/gate-mask.png"), 50)
+
+        self.run_mode = 'run'
+        self.current_pet_height = []
+        self.next_gate_height = [0,0,0]
+
+        self.offset_down = 90
+
+        self.start()
+
+    def run(self):
+        while self.run_mode == 'run':
+            screenshot_g = self.scale_picture(self.capture_window.get_screenshot_by_area([700, 1200, 1860, 90]), 50)
+            screenshot_f = self.scale_picture(self.capture_window.get_screenshot_by_area([200, 1250, 610, 90]), 50)
+
+            #cv.imshow("screenshot_g", screenshot_f)
+            #cv.waitKey(150)
+
+            rectangles_g = self.vision_stun.find(screenshot_g, self.needle_g, 0.8, 1)
+            rectangles_f = self.vision_stun.find(screenshot_f, self.needle_f, 0.7, 1) #, True, self.mask_f)
+
+            if len(rectangles_g) is not 0:
+                height = rectangles_g[0][1] + rectangles_g[0][3] + (self.offset_down /2)
+                if self.next_gate_height[2] is not height:
+                    self.next_gate_height.append(height)
+                if len(self.next_gate_height) > 3:
+                    self.next_gate_height.pop(0)
+                #pro_screen = self.vision_stun.draw_rectangles(screenshot_g, rectangles_g)
+                #cv.imshow("screenshot_g", pro_screen)
+                #cv.waitKey(150)
+            else:
+                pass
+
+            if len(rectangles_f) is not 0:
+                self.current_pet_height.append(rectangles_f[0][1] + rectangles_f[0][3] + self.offset_down)
+                if len(self.current_pet_height) > 5:
+                    self.current_pet_height.pop(0)
+
+            #print("pet_pos: ", self.current_pet_height)
+            #print("next gate: ", self.next_gate_height)
+
+    def scale_picture(self, img, scale_percent):
+        width = int(img.shape[1] * scale_percent / 100)
+        height = int(img.shape[0] * scale_percent / 100)
+
+        resized_img = cv.resize(img, (width, height), interpolation=4)
+
+        gray = cv.cvtColor(resized_img, cv.COLOR_BGR2GRAY)
+        thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
+
+        return thresh
+
+    def get_actual_pet_height(self):
+        return sum(self.current_pet_height) / len(self.current_pet_height)
+
+
+    def get_next_gate_height(self):
+        return self.next_gate_height
+
+
+
+
+
+

fruit.py

@@ -0,0 +1,167 @@
+import cv2 as cv
+import numpy as np
+from utils import mse
+from game_base_class import GameBase
+
+GREEN = 1
+YELLOW = 2
+RED = 3
+BLUE = 4
+ORANGE = 5
+
+
+class Fruit(GameBase):
+
+    def __init__(self, overlay):
+        super().__init__(overlay)
+
+        self.data_coordinates = np.zeros((7, 11), dtype=object)
+        self.observation = np.zeros((7, 11), dtype=int)
+
+        self.colors = [GREEN, YELLOW, RED, BLUE, ORANGE]
+
+        self.offset_left = 390
+        self.offset_down = 188
+
+        self.fill_data_coordinates()
+
+        self.needles = {GREEN: cv.imread("fruit/green.jpg", cv.IMREAD_COLOR),
+                        YELLOW: cv.imread("fruit/yellow.jpg", cv.IMREAD_COLOR),
+                        BLUE: cv.imread("fruit/blue.jpg", cv.IMREAD_COLOR),
+                        RED: cv.imread("fruit/red.jpg", cv.IMREAD_COLOR),
+                        ORANGE: cv.imread("fruit/orange.jpg", cv.IMREAD_COLOR)
+                        }
+
+    def fill_data_coordinates(self):
+        # 553 to 1861 = 1330 / 11 = 119
+        # 188 to 1022 = 1076 / 7 =  119
+        # 390 to 2000 = 1610 / 11 = 143
+        # 188 to 1210 = 1076 / 7 =  119
+
+        dim = 143
+        for e in range(0, 7, 1):
+            for i in range(0, 11, 1):
+                self.data_coordinates[e][i] = [i * dim, e * dim, dim, dim]
+
+    def assess_playfield_and_make_move(self):
+
+        new_observation, new_screenshot = self.get_current_board_state()
+
+        # wrong movement detection
+        # last board state is same as actual
+        if mse(new_observation, self.observation) == 0.0:
+            # no movement detected -> blow explosives or reset
+
+            self.reset_counter += 1
+            if self.reset_counter == 1:
+                pass
+            elif self.reset_counter == 2:
+                pass
+            elif self.reset_counter >= 3:
+                screenshot = self.capture_window.get_screenshot()
+                if self.check_for_button_and_execute(screenshot, self.reset_board):
+                    cv.waitKey(500)
+                screenshot = self.capture_window.get_screenshot()
+                if self.check_for_button_and_execute(screenshot, self.reset_confirm):
+                    cv.waitKey(500)
+
+                self.reset_counter = 0
+                return
+            else:
+                return
+
+        self.find_patterns_and_valid_moves(new_observation)
+        self.observation = new_observation
+        return new_observation
+
+    def get_current_board_state(self):
+        # get an updated image of the game
+        screenshot = self.capture_window.get_screenshot()
+        #screenshot = screenshot[900:1030, 540:1870]
+        # screenshot = cv.imread("field_farm.jpg")
+
+        # gray = cv.cvtColor(screenshot, cv.COLOR_BGR2GRAY)
+        # thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
+        if self.check_for_button_and_execute(screenshot, self.ok_button):
+            cv.waitKey(500)
+
+        screenshot = self.capture_window.get_screenshot()
+        screenshot = screenshot[188:1210, 390:2000]
+        # 553 to 1861 = 1330 / 11 = 119
+        # 188 to 1022
+        #cv.imshow("screenshot", screenshot)
+        #cv.waitKey(150)
+        # continue
+        data_coords = np.zeros((7, 11), dtype=object)
+        # field = Pickaxe_Field()
+        for needle_key in self.needles.keys():
+            # gray_needle = cv.cvtColor(self.needles[needle_key], cv.COLOR_BGR2GRAY)
+            # thresh_needle = cv.threshold(gray_needle, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
+            rectangles = self.vision_stun.find(screenshot, self.needles[needle_key], 0.78, 56)
+
+            #output_image = self.vision_stun.draw_rectangles(screenshot, rectangles)
+            #cv.imshow("output_image", output_image)
+            #cv.waitKey(150)
+
+            if len(rectangles) == 0:
+                continue
+            points = self.vision_stun.get_click_points(rectangles)
+
+            for point in points:
+                x, y = self.point_in_rect(point)
+                if x is not None and y is not None:
+                    data_coords[x][y] = int(needle_key)
+                    # self.change_value(x, y, int(needle_key))
+                    # print(field.data_value_grid)
+                    # cv.circle(screenshot, points[0], 7, (0, 255, 0), -1)
+                    # output_image = vision_stun.draw_rectangles(screenshot, rectangles)
+                    # cv.imshow("output_image", output_image)
+                    # cv.waitKey(150)
+        return data_coords, screenshot
+
+    def point_in_rect(self, point):
+        for e in range(0, 7, 1):
+            for i in range(0, 11, 1):
+                x1, y1, w, h = self.data_coordinates[e][i]
+                x2, y2 = x1 + w, y1 + h
+                x, y = point
+                if x1 < x and x < x2:
+                    if y1 < y and y < y2:
+                        return e, i
+        return None, None
+
+    def find_patterns_and_valid_moves(self, state):
+        for e in range(0, 7, 1):
+            for i in range(0, 11, 1):
+                if state[e, i] in self.colors:
+                #color in self.colors:
+                    if self.check_pairs_h(state, e, i):
+                        return
+                    if self.check_pairs_v(state, e, i):
+                        return
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+            if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                return
+
+    def check_pairs_h(self, state, e, i):
+        try:
+            #
+            if state[e, i] == state[e + 1, i]:
+                click_pt = self.get_click_point(self.data_coordinates[e, i])
+                self.dig_point(click_pt[0] + self.offset_left, click_pt[1] + self.offset_down, 100)
+                return True
+            return False
+        except:
+            return False
+
+    def check_pairs_v(self, state, e, i):
+        try:
+            #
+            if state[e, i] == state[e, i + 1]:
+                click_pt = self.get_click_point(self.data_coordinates[e, i])
+                self.dig_point(click_pt[0] + self.offset_left, click_pt[1] + self.offset_down, 100)
+                return True
+            return False
+        except:
+            return False

game_base_class.py

@@ -0,0 +1,279 @@
+import pydirectinput
+import random
+import cv2 as cv
+import numpy as np
+from window_capture import WindowCapture
+from vision import Vision
+from config_file import UserConfigs
+from time import time
+
+GREEN = 1
+YELLOW = 2
+RED = 3
+BLUE = 4
+PURPLE = 5
+RAINBOW = 6
+BIGBOMB = 7
+BOMB = 8
+ARROW_DOWN = 9
+ARROW_RIGHT = 10
+ROCK_1 = 11
+ROCK_2 = 12
+ROCK_3 = 13
+BURGER = 14
+PAB1 = 15
+GOLDBAR = 16
+MAGINENT = 21
+CHEMTRANT = 22
+TENESENT = 23
+CIBUTRANT = 24
+ARTISENT = 25
+
+MINING_LARGE = True
+
+class GameBase:
+
+    def __init__(self, overlay):
+        self.overlay = overlay
+
+        self.data_value_grid = np.zeros((8, 14), dtype=int)
+        self.data_coordinates = np.zeros((8, 14), dtype=object)
+        self.observation = np.zeros((8, 14), dtype=int)
+        self.data_score_map = np.zeros((8, 14), dtype=int)
+
+        self.explosives = [RAINBOW, ARROW_RIGHT, ARROW_DOWN, BIGBOMB, BOMB]
+        self.colors = [GREEN, YELLOW, RED, BLUE, MAGINENT, CHEMTRANT, TENESENT, CIBUTRANT, ARTISENT]
+
+        self.next_level = cv.imread("control_elements/next_level.jpg", cv.IMREAD_COLOR)
+        self.next_level_x = cv.imread("control_elements/next_level_x.jpg", cv.IMREAD_COLOR)
+        self.reset_board = cv.imread("control_elements/reset_button.jpg", cv.IMREAD_COLOR)
+        self.reset_confirm = cv.imread("control_elements/reset_confirm.jpg", cv.IMREAD_COLOR)
+        self.ok_button = cv.imread("control_elements/ok_button.jpg", cv.IMREAD_COLOR)
+
+        self.reset_counter = 0
+
+        self.stop_time = overlay.global_timeout_use.get()
+        self.breaks = overlay.hourly_breaks_use.get()
+        self.break_time = overlay.break_duration_use.get()
+
+        # initialize the user-class
+        self.config = UserConfigs()
+        # initialize the StunWindowCapture class
+        self.capture_window = WindowCapture(None, None, self.config)
+        # initialize the StunVision class
+        self.vision_stun = Vision()
+
+    def execute_main_loop(self):
+        start_time = time()
+        breaks = self.init_breaks()
+        while True:
+            self.check_breaks(start_time, breaks)
+            if self.overlay.run_mode == 'paused':
+                cv.waitKey(1)
+                continue
+            elif self.overlay.run_mode == 'stopped':
+                break
+            elif self.overlay.run_mode == 'finished':
+                break
+            self.assess_playfield_and_make_move()
+            cv.waitKey(500)
+
+    def init_breaks(self):
+        breaks = []
+        if int(self.breaks) == 0:
+            return breaks
+        #breaks.append(7)
+        for i in range(1, int(self.breaks) + 1, 1):
+            avr_in_sec = int(self.stop_time) * 60 * 60 / int(self.breaks)
+            breaks.append(random.randint(int(i * avr_in_sec * 0.60), int(i * avr_in_sec)))
+        return breaks
+
+    def check_breaks(self, start_time, breaks):
+        if int(self.stop_time) == 0:
+            return
+        if (time() - start_time) > float(self.stop_time) * 60 * 60:
+            self.overlay.run_mode = 'stopped'
+        for break_ in breaks:
+            elapsed = int(time() - start_time)
+            if elapsed > break_:
+                pause = random.randint(1, 3)
+                self.overlay.update_status_label("Break: " + str(pause) + "m")
+                cv.waitKey(pause * 60 * 1000)
+                breaks.remove(break_)
+                self.overlay.update_status_label("running")
+
+    def assess_playfield_and_make_move(self):
+        pass
+
+    #screenshot = screenshot[190:1230, 260:2090]
+    #[58: 1134, 230: 2113]
+    def fill_data_coordinates(self):
+        # 260 to 2090 = 1883 / 14 = 130
+        # 190 to 1230 = 1076 / 8 =  130
+        dim = 130
+        for e in range(0, 8, 1):
+            for i in range(0, 14, 1):
+                self.data_coordinates[e][i] = [i * dim, e * dim, dim, dim]
+
+    def check_for_button_and_execute(self, screen, needle, offset_left=0, offset_down=0):
+        rectangles = self.vision_stun.find(screen, needle, 0.70, 1)
+        if len(rectangles) == 0:
+            return False
+        point = self.vision_stun.get_click_points(rectangles)[0]
+        self.dig_point(point[0] + offset_left, point[1] + offset_down, 500)
+        return True
+
+    def check_for_next_level(self, screen, needle):
+        offset_left = 260
+        offset_down = 190
+        rectangles = self.vision_stun.find(screen, needle, 0.70, 1)
+        if len(rectangles) == 0:
+            return False
+        if self.detonate_explosive_when_stuck(self.observation):
+            return True
+        point = self.vision_stun.get_click_points(rectangles)[0]
+        self.dig_point(point[0] + offset_left, point[1] + offset_down, 500)
+        return True
+
+    def detonate_explosive_when_stuck(self, state):
+        for e in range(0, 8, 1):
+            for i in range(0, 14, 1):
+                for explosive in self.explosives:
+                    if self.local_pos_check(state, e, i, 0, 0, explosive):
+                        src_pt = self.get_click_point(self.data_coordinates[e, i])
+                        if self.local_pos_checks(state, e, i, 1, 0, self.colors):
+                            dest_pt = self.get_click_point(self.data_coordinates[e + 1, i])
+                            self.move_tile(src_pt, dest_pt)
+                            return True
+                        elif self.local_pos_checks(state, e, i, 0, 1, self.colors):
+                            dest_pt = self.get_click_point(self.data_coordinates[e, i + 1])
+                            self.move_tile(src_pt, dest_pt)
+                            return True
+                        elif self.local_pos_checks(state, e, i, -1, 0, self.colors):
+                            dest_pt = self.get_click_point(self.data_coordinates[e - 1, i])
+                            self.move_tile(src_pt, dest_pt)
+                            return True
+                        elif self.local_pos_checks(state, e, i, 0, -1, self.colors):
+                            dest_pt = self.get_click_point(self.data_coordinates[e, i - 1])
+                            self.move_tile(src_pt, dest_pt)
+                            return True
+                        else:
+                            continue
+        return False
+
+    def check_explosives(self, state, e, i):
+        for explosive in self.explosives:
+            if self.local_pos_check(state, e, i, 0, 0, explosive):
+                dest_pt = self.get_click_point(self.data_coordinates[e, i])
+                if self.local_pos_checks(state, e, i, 1, 0, self.explosives):
+                    src_pt = self.get_click_point(self.data_coordinates[e + 1, i])
+                    self.move_tile(src_pt, dest_pt)
+                elif self.local_pos_checks(state, e, i, 0, 1, self.explosives):
+                    src_pt = self.get_click_point(self.data_coordinates[e, i + 1])
+                    self.move_tile(src_pt, dest_pt)
+                elif self.local_pos_checks(state, e, i, -1, 0, self.explosives):
+                    src_pt = self.get_click_point(self.data_coordinates[e - 1, i])
+                    self.move_tile(src_pt, dest_pt)
+                elif self.local_pos_checks(state, e, i, 0, -1, self.explosives):
+                    src_pt = self.get_click_point(self.data_coordinates[e, i - 1])
+                    self.move_tile(src_pt, dest_pt)
+                else:
+                    continue
+                return True
+            else:
+                continue
+        return False
+
+    @staticmethod
+    def is_direction_in_bounce_and_same_color(state, loc, color):
+        x, y = loc
+        if x <= 7 and x >= 0 and y <= 13 and y >= 0:
+            if state[x, y] == color:
+                return 1
+        return 0
+
+    @staticmethod
+    def local_pos_check(state, e, i, e_check, i_check, needle):
+        if e + e_check >= 0 and e + e_check <= 7 and i + i_check >= 0 and i + i_check <= 13:
+            if state[e + e_check, i + i_check] == needle:
+                return True
+            else:
+                return False
+
+    @staticmethod
+    def local_pos_checks(state, e, i, e_check, i_check, needles):
+        if e + e_check >= 0 and e + e_check <= 7 and i + i_check >= 0 and i + i_check <= 13:
+            for needle in needles:
+                if state[e + e_check, i + i_check] == needle:
+                    return True
+                else:
+                    continue
+        return False
+
+    @staticmethod
+    def get_click_point(rectangle):
+        # Loop over all the rectangles
+        x, y, w, h = rectangle
+        # Determine the center position
+        center_x = x + int(w / 2)
+        center_y = y + int(h / 2)
+        # Save the points
+        return int(center_x), int(center_y)
+
+    def move_tile(self, point_source, point_dest):
+        offset_left = 260
+        offset_down = 190
+        pydirectinput.moveTo(point_source[0] + offset_left, point_source[1] + offset_down)
+        # pydirectinput.moveTo(0,0)
+        pydirectinput.mouseDown()
+        w = random.randint(25, 50)
+        cv.waitKey(100 + w)
+        pydirectinput.moveTo(point_dest[0] + offset_left, point_dest[1] + offset_down)
+        pydirectinput.mouseUp()
+        cv.waitKey(400 + w)
+
+    def check_for_button_and_click_it(self, button_url):
+        screenshot = self.capture_window.get_screenshot()
+        # gray = cv.cvtColor(screenshot, cv.COLOR_BGR2GRAY)
+        # thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
+        # gray_needle = cv.cvtColor(cv.imread(button_url, cv.IMREAD_UNCHANGED), cv.COLOR_BGR2GRAY)
+        # thresh_needle = cv.threshold(gray_needle, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1]
+        needle = cv.imread(button_url, cv.IMREAD_UNCHANGED)
+        # rectangles = self.vision_stun.find(thresh, thresh_needle, 0.4, 1)
+        rectangles = self.vision_stun.find(screenshot, needle, 0.7, 1)
+
+        if len(rectangles) == 1:
+            pointis = self.vision_stun.get_click_points(rectangles)
+            for pointi in pointis:
+                self.dig_point(pointi[0], pointi[1], 150)
+
+    @staticmethod
+    def dig_point(point1, point2, dig_time):
+        pydirectinput.moveTo(point1, point2)
+        cv.waitKey(dig_time)
+        pydirectinput.mouseDown()
+        w = random.randint(50, 100)
+        cv.waitKey(w)
+        pydirectinput.mouseUp()
+
+    @staticmethod
+    def move_to(x, y):
+        point_src = (1113, 598)
+        pydirectinput.moveTo(point_src[0], point_src[1])
+        pydirectinput.mouseDown()
+        w = random.randint(1, 100)
+        cv.waitKey(150 + w)
+        pydirectinput.moveTo(x, y)
+        pydirectinput.mouseUp()
+        cv.waitKey(500 + w)
+
+    def point_in_rect(self, point):
+        for e in range(0, 8, 1):
+            for i in range(0, 14, 1):
+                x1, y1, w, h = self.data_coordinates[e][i]
+                x2, y2 = x1 + w, y1 + h
+                x, y = point
+                if x1 < x and x < x2:
+                    if y1 < y and y < y2:
+                        return e, i
+        return None, None

keyboard_thread.py

@@ -0,0 +1,32 @@
+import threading
+import cv2 as cv
+import keyboard
+
+
+class KeyboardEvent(threading.Thread):
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+
+        self.run_mode = 'run'
+        self.offset_value = 0
+        self.start()
+    def run(self):
+        while self.run_mode == 'run':
+            if keyboard.is_pressed('up'):  # if key 'q' is pressed
+                self.offset_value = -75
+            elif keyboard.is_pressed('down'):
+                self.offset_value = 75
+            elif keyboard.is_pressed('left') or keyboard.is_pressed('right'):
+                self.offset_value = 0
+            cv.waitKey(10)
+
+    def callback(self):
+        pass
+
+    def destroy(self):
+        self.destroy()
+
+    def get_run_mode(self):
+        return self.run_mode
+

litris.py

@@ -0,0 +1,235 @@
+from copy import copy
+
+import cv2 as cv
+import numpy as np
+from time import time
+from game_base_class import GameBase
+from pynput.keyboard import Key, Controller
+from field import Field
+from tetromino import Tetromino
+from optimizer import Optimizer
+from litris_stone_id_thread import NewStoneID
+
+class Litris(GameBase):
+
+    def __init__(self, overlay):
+        super().__init__(overlay)
+
+        self.keyboard = Controller()
+
+        self.offset_left = 610
+        self.offset_down = 40
+
+        self.field = Field()
+
+        self.litris_reset_board = cv.imread("control_elements/sodoku_reset_button.jpg", cv.IMREAD_COLOR)
+
+        self.stone_id_thread = NewStoneID()
+
+        self.move_mode = 1
+        self.moved_around_full = False
+
+        self.field_state_storage = {
+            1: self.field,
+            2: self.field,
+            3: self.field,
+            4: self.field
+        }
+
+    def reset(self):
+        self.field.reset_field()
+        self.field.cleared_rows = 1
+        self.move_mode = 1
+        self.moved_around_full = False
+
+    def assess_playfield_and_make_move(self):
+        last_letter_received = time()
+        while True:
+            if self.stone_id_thread.get_pick_up_status() == False:
+                if (time() - last_letter_received) >= 5:
+                    self.reset()
+                    last_letter_received = time()
+                    self.dig_point(1500, 980, 100)
+                    if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                        return
+                    continue
+                if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused':
+                    return
+                cv.waitKey(25)
+                continue
+
+
+            current_letter = self.stone_id_thread.get_actual_letter()
+            print("current_letter: ", current_letter)
+            last_letter_received = time()
+
+
+            current_tetromino = Tetromino.create(current_letter)
+            if self.move_mode == 2:
+                current_tetromino.rotate(3)
+            elif self.move_mode == 3:
+                current_tetromino.rotate(2)
+            elif self.move_mode == 4:
+                current_tetromino.rotate(1)
+
+
+            opt = Optimizer.get_optimal_drop(self.field, current_tetromino)
+            rotation = opt['tetromino_rotation']
+            column = opt['tetromino_column']
+            print("Rota:", rotation)
+            print("column:", column)
+            current_tetromino.rotate(rotation)
+            offset_col = current_tetromino.get_offset_column(rotation, self.move_mode)
+            print("offset column:", offset_col)
+            self.field.drop(current_tetromino, column)
+            self.move_stone(column - offset_col, rotation)
+            self.drop_down()
+            print(self.field)
+            if self.field.get_line_count() >= 6 and self.field.height() <= 2 and self.field.check_crucial_pos_to_be_free():
+                if self.field.predict_gaps_in_next_rotation() <= 3:
+                    self.field_state_storage[self.move_mode] = copy(self.field)
+                    self.update_move_mode()
+                    #self.field.state = self.stone_id_thread.get_current_board_state()
+                    self.field.rotate_state()
+                    #self.update_move_mode()
+                    self.field.reset_half_field()
+                    self.update_field_with_stored_edges()
+                    #field_mem = copy(self.field)
+                    #self.field = copy(self.field_mem)
+                    #self.field_mem = copy(field_mem)
+
+                    self.field.cleared_rows = 1
+
+                    cv.waitKey(100)
+            self.stone_id_thread.set_pick_up_status(False)
+
+    def update_field_with_stored_edges(self):
+        if self.move_mode == 1 and self.moved_around_full:
+            state_copy = Field.rotate_90_degree_clckwise(copy(self.field_state_storage[2].state))
+            for i in range(11,20,1):
+                for e in range(0,2,1):
+                    self.field.state[i][e] = state_copy[i][e]
+        elif self.move_mode == 2 and self.moved_around_full:
+            state_copy = Field.rotate_90_degree_clckwise(copy(self.field_state_storage[3].state))
+            for i in range(11,20,1):
+                for e in range(0,2,1):
+                    self.field.state[i][e] = state_copy[i][e]
+        elif self.move_mode == 3 and self.moved_around_full:
+            state_copy = Field.rotate_90_degree_clckwise(copy(self.field_state_storage[4].state))
+            for i in range(11, 20, 1):
+                for e in range(0, 2, 1):
+                    self.field.state[i][e] = state_copy[i][e]
+        elif self.move_mode == 4:
+            state_copy = Field.rotate_90_degree_clckwise(copy(self.field_state_storage[1].state))
+            for i in range(11,20,1):
+                for e in range(0,2,1):
+                    self.field.state[i][e] = state_copy[i][e]
+            self.moved_around_full = True
+
+    def drop_down(self):
+        if self.move_mode == 1:
+            down = Key.down
+            left = Key.left
+            right = Key.right
+        elif self.move_mode == 2:
+            down = Key.left
+            left = Key.up
+            right = Key.down
+        elif self.move_mode == 3:
+            down = Key.up
+            left = Key.right
+            right = Key.left
+        elif self.move_mode == 4:
+            down = Key.right
+            left = Key.down
+            right = Key.up
+        for i in range(1, 10, 1):
+            self.keyboard.press(down)
+            self.keyboard.release(down)
+            print("drop down pressed:", down)
+            cv.waitKey(40)
+
+    def update_move_mode(self):
+        if self.move_mode <=3:
+            self.move_mode = self.move_mode + 1
+        elif self.move_mode == 4:
+            self.move_mode = 1
+
+    def move_stone(self, col_movement, rotation):
+        if col_movement is None:
+            return
+
+        if self.move_mode == 1:
+            down = Key.down
+            left = Key.left
+            right = Key.right
+        elif self.move_mode == 2:
+            down = Key.left
+            left = Key.up
+            right = Key.down
+        elif self.move_mode == 3:
+            down = Key.up
+            left = Key.right
+            right = Key.left
+        elif self.move_mode == 4:
+            down = Key.right
+            left = Key.down
+            right = Key.up
+
+        # Press and release space
+        self.keyboard.press(down)
+        self.keyboard.release(down)
+        print("direction pressed: ", down)
+        cv.waitKey(60)
+
+        if rotation == 3:
+            self.keyboard.press('e')
+            self.keyboard.release('e')
+            print("rotation 1 pressed: e")
+            cv.waitKey(30)
+        elif rotation == 2:
+            self.keyboard.press('e')
+            self.keyboard.release('e')
+            print("rotation 2 pressed: e 1")
+            cv.waitKey(30)
+            self.keyboard.press('e')
+            self.keyboard.release('e')
+            print("rotation 2 pressed: e 2")
+            cv.waitKey(30)
+        elif rotation == 1:
+            self.keyboard.press('e')
+            self.keyboard.release('e')
+            print("rotation 3 pressed: e 1")
+            cv.waitKey(30)
+            self.keyboard.press('e')
+            self.keyboard.release('e')
+            print("rotation 3 pressed: e 2")
+            cv.waitKey(30)
+            self.keyboard.press('e')
+            self.keyboard.release('e')
+            print("rotation 3 pressed: e 3")
+            cv.waitKey(30)
+
+        if col_movement < 0:
+            for i in range(0, col_movement, - 1):
+                self.keyboard.press(left)
+                self.keyboard.release(left)
+                print("move left 3 pressed:", left)
+                cv.waitKey(30)
+        else:
+            for i in range(0, col_movement, 1):
+                self.keyboard.press(right)
+                self.keyboard.release(right)
+                print("move right 3 pressed:", right)
+                cv.waitKey(30)
+
+    def point_in_rect(self, point):
+        for e in range(0, 20, 1):
+            for i in range(0, 20, 1):
+                x1, y1, w, h = self.data_coordinates[e][i]
+                x2, y2 = x1 + w, y1 + h
+                x, y = point
+                if x1 < x and x < x2:
+                    if y1 < y and y < y2:
+                        return e, i
+        return None, None