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

@@ -59,9 +59,12 @@ class UserConfigs:
         else:
             pass
 
-    def returnDiggingWindowPos2(self):
+    def returnDiggingWindowPos2(self, large=True):
         if self.user == self.THALOUSER:
+            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,184 +0,0 @@
-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
-
-    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()