Merge remote-tracking branch 'origin/master'

bug fix equip multi

.gitignore

@@ -0,0 +1 @@
+/venv/

.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.5, 1)
-        if len(spawn_1) == 1:
-            spawn_button_active = True
-            points = vision_stun.get_click_points(spawn_1)
-            for i in range(0, 200, 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.70, 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

@@ -17,7 +17,17 @@ class UserConfigs:
         elif user_from_env == self.EDDIEUSER:
             self.user = self.EDDIEUSER
         else:
-            self.user = self.ADWAUSER
+            self.user = self.THALOUSER
+
+    def returnOKWindowPos(self):
+        if self.user == self.THALOUSER:
+            return [310, 200, 1120, 920]
+        elif self.user == self.ADWAUSER:
+            return [740, 450, 1625, 985]
+        elif self.user == self.EDDIEUSER:
+            return [740, 450, 1625, 985]
+        else:
+            pass
 
     def returnMagicWindowPos(self):
         if self.user == self.THALOUSER:
@@ -49,9 +59,12 @@ class UserConfigs:
         else:
             pass
 
-    def returnEquipmentWindowPos(self):
+    def returnDiggingWindowPos2(self, large=True):
         if self.user == self.THALOUSER:
-            return [1800, 1150, 0, 0]
+            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:
@@ -59,6 +72,26 @@ class UserConfigs:
         else:
             pass
 
+    def returnEquipmentWindowPos(self):
+        if self.user == self.THALOUSER:
+            return [1800, 1150, 250, 250]
+        elif self.user == self.ADWAUSER:
+            return [740, 450, 1625, 985]
+        elif self.user == self.EDDIEUSER:
+            return [740, 450, 1625, 985]
+        else:
+            pass
+
+    def returnDiggingOverlayPos(self):
+        if self.user == self.THALOUSER:
+            return '1440x1150+570+22'
+        elif self.user == self.ADWAUSER:
+            return '160x160+-900+600'
+        elif self.user == self.EDDIEUSER:
+            return '330x45+-900+920'
+        else:
+            pass
+
     def return_database_ip(self):
         if self.user == self.THALOUSER:
             return "192.168.178.201"

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

@@ -0,0 +1,23 @@
+import cv2 as cv
+import os
+import numpy as np
+from window_capture import WindowCapture
+from config_file import UserConfigs
+
+#uc = UserConfigs()
+#wc = WindowCapture(None, None, uc)
+#screen = wc.get_screenshot(False)
+# load the original input image and display it to our screen
+
+#filename = "equip/chests/chest_23_32"
+path = "flappy/"
+os.chdir(path)
+
+for entry in os.listdir():
+    if entry.endswith('.png'):
+
+        nelk = entry[:len(entry)-4]
+        if nelk.find('-mask') == -1:
+            out = nelk + "-mask.png"
+            img = cv.imread(entry, cv.IMREAD_UNCHANGED)
+            cv.imwrite(out, img[:, :, 3])

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

cv_test_2.py

@@ -0,0 +1,172 @@
+from __future__ import print_function
+import sys
+import cv2 as cv
+import numpy as np
+from hsvfilter import HsvFilter
+
+use_mask = False
+img = None
+templ = None
+mask = None
+image_window = "Source Image"
+result_window = "Result window"
+match_method = 3
+max_Trackbar = 5
+
+
+def main():
+
+
+    global img
+    global templ
+    img = cv.imread("equip/rings/test_screen.jpg", cv.IMREAD_COLOR)
+    templ = cv.imread("equip/rings/ring_1_32.jpg", cv.IMREAD_COLOR)
+
+    hsv = HsvFilter(13, 40, 85, 135, 255, 255, 0, 0, 55, 53)
+    #img = apply_hsv_filter(img, hsv)
+    #templ = apply_hsv_filter(templ, hsv)
+
+
+    global use_mask
+    use_mask = True
+    global mask
+    mask = cv.imread("equip/rings/ring_1_32-mask.png", cv.IMREAD_COLOR)
+
+
+    cv.namedWindow(image_window, cv.WINDOW_AUTOSIZE)
+    cv.namedWindow(result_window, cv.WINDOW_AUTOSIZE)
+
+    trackbar_label = 'Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED'
+    cv.createTrackbar(trackbar_label, image_window, match_method, max_Trackbar, MatchingMethod)
+
+    MatchingMethod(match_method)
+
+    cv.waitKey(0)
+    return 0
+
+def draw_rectangles(haystack_img, rectangles):
+    # these colors are actually BGR
+    line_color = (0, 255, 0)
+    line_type = cv.LINE_4
+    pic = None
+    for (x, y, w, h) in rectangles:
+        # determine the box positions
+        top_left = (x, y)
+        bottom_right = (x + w, y + h)
+        # draw the box
+        cv.rectangle(haystack_img, top_left, bottom_right, line_color, lineType=line_type)
+
+        #pic = haystack_img[y:y + h, x:x + w]
+
+    return haystack_img
+
+def shift_channel(c, amount):
+    if amount > 0:
+        lim = 255 - amount
+        c[c >= lim] = 255
+        c[c < lim] += amount
+    elif amount < 0:
+        amount = -amount
+        lim = amount
+        c[c <= lim] = 0
+        c[c > lim] -= amount
+    return c
+
+def apply_hsv_filter(original_image, hsv_filter):
+    # convert image to HSV
+    hsv = cv.cvtColor(original_image, cv.COLOR_BGR2HSV)
+
+
+    # add/subtract saturation and value
+    h, s, v = cv.split(hsv)
+    s = shift_channel(s, hsv_filter.sAdd)
+    s = shift_channel(s, -hsv_filter.sSub)
+    v = shift_channel(v, hsv_filter.vAdd)
+    v = shift_channel(v, -hsv_filter.vSub)
+    hsv = cv.merge([h, s, v])
+
+    # Set minimum and maximum HSV values to display
+    lower = np.array([hsv_filter.hMin, hsv_filter.sMin, hsv_filter.vMin])
+    upper = np.array([hsv_filter.hMax, hsv_filter.sMax, hsv_filter.vMax])
+    # Apply the thresholds
+    mask = cv.inRange(hsv, lower, upper)
+    result = cv.bitwise_and(hsv, hsv, mask=mask)
+
+    # convert back to BGR for imshow() to display it properly
+    img = cv.cvtColor(result, cv.COLOR_HSV2BGR)
+
+    return img
+
+def MatchingMethod(param):
+    global match_method
+    match_method = param
+
+    img_display = img.copy()
+
+    method_accepts_mask = (cv.TM_SQDIFF == match_method or match_method == cv.TM_CCORR_NORMED)
+    if (use_mask and method_accepts_mask):
+        result = cv.matchTemplate(img, templ, match_method, None, mask)
+    else:
+        result = cv.matchTemplate(img, templ, match_method)
+    #_minVal, _maxVal, minLoc, maxLoc = cv.minMaxLoc(result, None)
+    cv.normalize(result, result, 0, 1, cv.NORM_MINMAX, -1)
+    #_minVal, _maxVal, minLoc, maxLoc = cv.minMaxLoc(result, None)
+
+    locations = np.where(result >= 0.91)
+    locations = list(zip(*locations[::-1]))
+
+    needle_w = templ.shape[1]
+    needle_h = templ.shape[0]
+
+    find_num = 20
+    idx_1d = np.argpartition(result.flatten(), -find_num)[-find_num:]
+    #new_res = result.flatten()[idx_1d]
+    #new_res.append()
+    idx_2d = np.unravel_index(idx_1d, result.shape)
+
+    rectangles = []
+    for i in range(0, len(idx_2d[0]), 1):
+        y = int(idx_2d[0][i])
+        x = int(idx_2d[1][i])
+        rect = [x, y, needle_w, needle_h]
+        # Add every box to the list twice in order to retain single (non-overlapping) boxes
+        rectangles.append(rect)
+        rectangles.append(rect)
+
+
+    for loc in locations:
+        rect = [int(loc[0]), int(loc[1]), needle_w, needle_h]
+        # Add every box to the list twice in order to retain single (non-overlapping) boxes
+        #rectangles.append(rect)
+        #rectangles.append(rect)
+
+
+    rectangles, weights = cv.groupRectangles(rectangles, groupThreshold=1, eps=0.5)
+    keep_rects = []
+    for rect in rectangles:
+        w = rect[0]
+        h = rect[1]
+        x = rect[2] + w
+        y = rect[3] + h
+        screenshot_pos = img_display[h:y, w:x]  # (w, h, x+w, y+h)
+        result2 = cv.matchTemplate(screenshot_pos, templ, 5)
+        _minVal2, _maxVal2, minLoc2, maxLoc2 = cv.minMaxLoc(result2, None)
+        if _maxVal2 >= 0.5:
+            keep_rects.append(rect)
+            print("matching error")
+
+
+
+
+
+
+    res1 = draw_rectangles(img_display, keep_rects)
+    res2 = draw_rectangles(img, keep_rects)
+
+    cv.imshow(image_window, res1)
+    cv.imshow(result_window, res2)
+
+
+
+if __name__ == "__main__":
+    main()

digging_main.py

@@ -1,182 +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
-from tresh_util import super_tresh_main, super_tresh_needle
-
-
-def run():
-    # initialize the user-class
-    config = UserConfigs()
-
-    # PLOT_TO_USE = "business"
-    PLOT_TO_USE = "main_plot"
-    GRID_SIZE_WIDTH = 30
-    GRID_SIZE_DEPTH = 24
-    DIG_TIME = 150
-
-    # initialize the StunWindowCapture class
-    try:
-        capture_window = WindowCapture(
-            None, "dig", 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
-
-    # plot_to_use = "business"
-    plot_to_use = "main_plot"
-
-    # initialize the StunVision class
-    vision_stun = Vision()
-    # initialize the StunOverlay class
-    hsv_filter = HsvFilter(0, 0, 124, 15, 255, 168, 0, 255, 0, 0)
-
-    loop_time = time()
-    event_time = 0.0
-    pointstore = []
-    max_results = 0
-    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)
-            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
-
-        needles = []
-        if PLOT_TO_USE == "business":
-            needles.append(cv.imread("dig/Brown0.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/1.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/2.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/3.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/4.jpg", cv.IMREAD_UNCHANGED))
-        else:
-            needles.append(cv.imread("dig/H1.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/H2.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/H3.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/H4.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/D1.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/D2.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/D3.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/D3.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/D4.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/D5.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/D6.jpg", cv.IMREAD_UNCHANGED))
-            needles.append(cv.imread("dig/D7.jpg", cv.IMREAD_UNCHANGED))
-
-        for needle in needles:
-            # do object detection
-            screenshot = capture_window.get_screenshot()
-            rectangles = vision_stun.find(screenshot, needle, 0.8, 1)
-            # draw the detection results onto the original image
-            if len(rectangles) == 0:
-                continue
-            #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)
-            for point in points:
-                # 46 + 1 * 30 1410 == 1815 - 405             return [1410, 1128, 402, 22]
-                # 44 + 1 * 30 1350 == 1790 - 440
-                #                 left_border = 402, 432
-                #                 right_border = 1812, 1782
-                #                 upper_border = 22, 50
-                #                 lower_border = 1150, 1120
-
-                size = rectangles[0][2] + 1
-
-                left = int(round(rectangles[0][0] / size, 0))  # 4
-                down = int(round(rectangles[0][1] / size, 0))  # 23
-                offset_left = config.returnDiggingWindowPos()[2]
-                offset_down = config.returnDiggingWindowPos()[3]
-                # 167 1055 start
-                # 3x47 left 26x right to 30
-                # 1x down 22x up to 24
-
-                # start 167, end 167 - (47 * 3), step -47
-                start_left = point[0] - (size * left)
-                start_up = point[1] - (size * down)
-                for f in range(start_up, start_up + (size * GRID_SIZE_DEPTH), size):
-                    for i in range(start_left, start_left + (size * GRID_SIZE_WIDTH), size):
-                        pydirectinput.moveTo(i + offset_left, f + offset_down)
-                        pydirectinput.mouseDown()
-                        w = random.randint(1, 50)
-                        cv.waitKey(DIG_TIME + w)
-                        pydirectinput.mouseUp()
-                        if keyboard.is_pressed('p') == True or pause == True:
-                            pause = True
-                            break
-
-                    if PLOT_TO_USE == "main_plot":
-                        screenshot = capture_window.get_screenshot()
-                        rectangles = vision_stun.find(screenshot, cv.imread("dig/ok_button.jpg", cv.IMREAD_UNCHANGED), 0.5,
-                                                  1)
-                        # draw the detection results onto the original image
-                        output_image = vision_stun.draw_rectangles(screenshot, rectangles)
-                        if len(rectangles) == 1:
-                            pointis = vision_stun.get_click_points(rectangles)
-                            for pointi in pointis:
-                                pydirectinput.moveTo(pointi[0] + offset_left, pointi[1] + offset_down)
-                                pydirectinput.mouseDown()
-                                w = random.randint(1, 50)
-                                cv.waitKey(DIG_TIME + 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
-                    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
-
-
-
-        # debug the loop rate
-        print('FPS {}'.format(1 / (time() - loop_time)))
-        loop_time = time()
-        cv.waitKey(150)
-
-
-if __name__ == "__main__":
-    run()