diff --git a/breed1.jpg b/breed1.jpg deleted file mode 100644 index 6fc6e58..0000000 Binary files a/breed1.jpg and /dev/null differ diff --git a/breed2.jpg b/breed2.jpg deleted file mode 100644 index ba1f903..0000000 Binary files a/breed2.jpg and /dev/null differ diff --git a/candy-c/grid.jpg b/candy-c/grid.jpg deleted file mode 100644 index 9ac1662..0000000 Binary files a/candy-c/grid.jpg and /dev/null differ diff --git a/candy-c/repeat.jpg b/candy-c/repeat.jpg deleted file mode 100644 index 408e0ee..0000000 Binary files a/candy-c/repeat.jpg and /dev/null differ diff --git a/candy-c/reset.jpg b/candy-c/reset.jpg deleted file mode 100644 index 039e9a9..0000000 Binary files a/candy-c/reset.jpg and /dev/null differ diff --git a/combine_main.py b/combine_main.py deleted file mode 100644 index 6796763..0000000 --- a/combine_main.py +++ /dev/null @@ -1,202 +0,0 @@ -import random -from time import time -from window_capture import WindowCapture -from vision import Vision -import cv2 as cv -import pytesseract -from hsvfilter import HsvFilter -from config_file import UserConfigs -# import pyautogui -import pydirectinput -import keyboard - - -def run(): - # initialize the user-class - config = UserConfigs() - - # initialize the StunWindowCapture class - try: - capture_window = WindowCapture( - None, "magic", config) - video_mode = False - except: - # StunWindowCapture.list_window_names() - # print("Game not running, switching to video mode") - # capture_window = cv.VideoCapture("snip_slam.mp4") - video_mode = True - - # initialize the StunVision class - vision_stun = Vision() - # initialize the StunOverlay class - hsv_filter_orange = HsvFilter(10, 156, 0, 17, 255, 255, 0, 0, 0, 0) - hsv_filter_p = HsvFilter(130, 156, 0, 179, 255, 255, 0, 0, 0, 0) - hsv_filter_b = HsvFilter(88, 156, 0, 128, 255, 255, 0, 0, 0, 0) - hsv_filter_g = HsvFilter(34, 156, 0, 74, 255, 255, 0, 0, 0, 0) - hsv_filter_y = HsvFilter(24, 156, 0, 33, 255, 255, 0, 0, 0, 0) - hsv_filter_0 = HsvFilter(0, 0, 0, 179, 255, 255, 255, 0, 0, 0) - hsv_filter_w = HsvFilter(69, 25, 0, 94, 255, 255, 0, 0, 0, 0) - - loop_time = time() - pause = True - - magic_list = {"1": "body", "2": "finding", "3": "mind", "4": "perceiving", "5": "physical", "6": "seeing", - "7": "spiritual"} - tier_list = {"1": "0", "2": "orange", "3": "y", "4": "g", "5": "b", "6": "p"} # , "w"} - hsv_filter_list = {"1": hsv_filter_0, "2": hsv_filter_orange, "3": hsv_filter_y, "4": hsv_filter_g, - "5": hsv_filter_b, "6": hsv_filter_p} - - needle_list = [] - hsv_list = [] - for key1 in tier_list: - for key2 in magic_list: - - needle_list.append(cv.imread("magic/" + magic_list[key2] + "_" + tier_list[key1] + ".jpg", - cv.IMREAD_UNCHANGED)) - hsv_list.append(hsv_filter_list[key1]) - - - while True: - if keyboard.is_pressed('p') == True: - pause = True - print('q pressed') - elif keyboard.is_pressed('o') == True: - pause = False - print('o pressed') - if pause: - # cv.waitKey(500) - print("pausing") - continue - - if video_mode: - break - else: - try: - # get an updated image of the game - screenshot = capture_window.get_screenshot() - # screenshot = cv.imread("buffbar.jpg") - except: - capture_window.release() - print("Game window not available - shutting down application") - break - #cv.imshow("screenshot", screenshot) - #cv.waitKey(150) - #continue - - spawn_1 = vision_stun.find(screenshot, cv.imread("magic/spawn_1.jpg", cv.IMREAD_UNCHANGED), 0.25, 1) - if len(spawn_1) == 1: - spawn_button_active = True - points = vision_stun.get_click_points(spawn_1) - for i in range(0, 100, 1): - pydirectinput.moveTo(points[0][0], points[0][1]) - pydirectinput.mouseDown() - w = random.randint(1, 50) - cv.waitKey(30 + w) - pydirectinput.mouseUp() - else: - spawn_0 = vision_stun.find(screenshot, cv.imread("magic/spawn_0.jpg", cv.IMREAD_UNCHANGED), 0.7, 1) - points = vision_stun.get_click_points(spawn_0) - for point in points: - pydirectinput.moveTo(point[0], point[1]) - pydirectinput.mouseDown() - cv.waitKey(500) - pydirectinput.mouseUp() - continue - - # for needles in needle_list: - for rer in range(0, len(needle_list), 1): - #for needle in needle_list: - # do object detection - # processed_image = vision_stun.apply_hsv_filter(screenshot, hsv_filter) - # screenshot = capture_window.get_screenshot() - #cv.imshow("output_image", needle_list[rer]) - #cv.waitKey(150) - - while True: - screenshot = capture_window.get_screenshot() - processed_screenshot = vision_stun.apply_hsv_filter(screenshot, hsv_list[rer]) - processed_needle = vision_stun.apply_hsv_filter(needle_list[rer], hsv_list[rer]) - - #cv.imshow("output_image", processed_screenshot) - cv.imshow("output_needle", processed_needle) - cv.waitKey(150) - - rectangles = vision_stun.find(processed_screenshot, processed_needle, 0.7, 2) - # draw the detection results onto the original image - #output_image = vision_stun.draw_rectangles(screenshot, rectangles) - #cv.imshow("output_image", output_image) - #cv.waitKey(150) - - # only trigger ocr reading if a stun is detected - points = vision_stun.get_click_points(rectangles) - if len(points) == 2: - pydirectinput.moveTo(points[0][0], points[0][1]) - pydirectinput.mouseDown() - w = random.randint(1, 100) - cv.waitKey(250 + w) - pydirectinput.moveTo(points[1][0], points[1][1]) - pydirectinput.mouseUp() - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - else: - break - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - - needles_white = [] - needles_white.append(cv.imread("magic/body_w.jpg", cv.IMREAD_UNCHANGED)) - needles_white.append(cv.imread("magic/finding_w.jpg", cv.IMREAD_UNCHANGED)) - needles_white.append(cv.imread("magic/mind_w.jpg", cv.IMREAD_UNCHANGED)) - needles_white.append(cv.imread("magic/perceiving_w.jpg", cv.IMREAD_UNCHANGED)) - needles_white.append(cv.imread("magic/physical_w.jpg", cv.IMREAD_UNCHANGED)) - needles_white.append(cv.imread("magic/seeing_w.jpg", cv.IMREAD_UNCHANGED)) - needles_white.append(cv.imread("magic/spiritual_w.jpg", cv.IMREAD_UNCHANGED)) - - for needle_w in needles_white: - # do object detection - screenshot = capture_window.get_screenshot() - processed_screenshot = vision_stun.apply_hsv_filter(screenshot,hsv_filter_w) - processed_needle = vision_stun.apply_hsv_filter(needle_w, hsv_filter_w) - rectangles = vision_stun.find(processed_screenshot, processed_needle, 0.7, 1) - # draw the detection results onto the original image - # output_image = vision_stun.draw_rectangles(screenshot, rectangles) - # cv.imshow("output_image", output_image) - # cv.waitKey(150) - - points = vision_stun.get_click_points(rectangles) - if len(points) >= 1: - pydirectinput.moveTo(points[0][0], points[0][1]) - pydirectinput.mouseDown() - w = random.randint(1, 100) - cv.waitKey(100 + w) - pydirectinput.mouseUp() - screenshot = capture_window.get_screenshot() - rectangles = vision_stun.find(screenshot, cv.imread("magic/collect.jpg", cv.IMREAD_UNCHANGED), 0.8, 1) - points = vision_stun.get_click_points(rectangles) - if len(points) >= 1: - pydirectinput.moveTo(points[0][0], points[0][1]) - pydirectinput.mouseDown() - w = random.randint(1, 100) - cv.waitKey(100 + w) - pydirectinput.mouseUp() - - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - - # debug the loop rate - print('FPS {}'.format(1 / (time() - loop_time))) - loop_time = time() - cv.waitKey(150) - - -if __name__ == "__main__": - run() diff --git a/combine_main_ui.py b/combine_main_ui.py deleted file mode 100644 index 07b6209..0000000 --- a/combine_main_ui.py +++ /dev/null @@ -1,185 +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 combine_overlay import CombineOverlay - - -def run(): - # initialize the user-class - config = UserConfigs() - overlay = CombineOverlay() - - while True: - if overlay.run_mode == 'stopped': - overlay.update_status_label("stopped", "0") - 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", "0") - overlay.run_mode = 'init' - continue - else: - break - - capture_window = WindowCapture(None, "magic", config) - - # 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 overlay.run_mode == 'paused': - continue - elif overlay.run_mode == 'stopped': - break - - try: - # get an updated image of the game - screenshot = capture_window.get_screenshot() - # screenshot = cv.imread("buffbar.jpg") - except: - capture_window.release() - print("Game window not available - shutting down application") - break - #cv.imshow("screenshot", screenshot) - #cv.waitKey(150) - #continue - - spawn_1 = vision_stun.find(screenshot, cv.imread("magic/spawn_1.jpg", cv.IMREAD_UNCHANGED), 0.25, 1) - if len(spawn_1) == 1: - spawn_button_active = True - points = vision_stun.get_click_points(spawn_1) - for i in range(0, 100, 1): - pydirectinput.moveTo(points[0][0], points[0][1]) - pydirectinput.mouseDown() - w = random.randint(1, 50) - cv.waitKey(30 + w) - pydirectinput.mouseUp() - if overlay.run_mode == 'stopped': - break - 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() - if overlay.run_mode == 'stopped': - break - continue - if overlay.run_mode == 'stopped': - break - # for needles in needle_list: - for rer in range(0, len(needle_list), 1): - 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]) - - rectangles = vision_stun.find(processed_screenshot, processed_needle, 0.7, 2) - # draw the detection results onto the original image - - # 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 overlay.run_mode == 'stopped': - break - else: - break - if overlay.run_mode == 'stopped': - break - if overlay.run_mode == 'stopped': - 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 overlay.run_mode == 'stopped': - break - if overlay.run_mode == 'stopped': - break - -if __name__ == "__main__": - run() diff --git a/combine_overlay.py b/combine_overlay.py deleted file mode 100644 index 16a17b6..0000000 --- a/combine_overlay.py +++ /dev/null @@ -1,66 +0,0 @@ -# Run tkinter code in another thread -import threading -import tkinter as tk -from tkinter import ttk - - -class CombineOverlay(threading.Thread): - - def __init__(self): - threading.Thread.__init__(self) - - self.run_mode = 'init' - - self.root = tk.Tk - - self.ButtonFrame = tk.Frame - - self.StartButton = tk.Button - self.StopButton = tk.Button - self.TkPosition = '133x52+60+600' - - self.StatusLabel = tk.Label - - self.start() - - def run(self): - self.root = tk.Tk() - self.ButtonFrame = tk.Frame(self.root) - self.StartButton = tk.Button(self.ButtonFrame, text="Start", command=self.start_button_callback, width='8') - self.StartButton.grid(row=0, column=0) - self.StopButton = tk.Button(self.ButtonFrame, text="Stop", command=self.stop_button_callback, width='8', - state=tk.DISABLED) - self.StopButton.grid(row=0, column=1) - - self.ButtonFrame.grid(row=3, column=0, columnspan=2) - - self.StatusLabel = tk.Label(self.root, text="", font=("Helvetica", 10, "bold"), - background="grey") - self.StatusLabel.grid(row=4, column=0, columnspan=2) - - # self.ClearButton.pack(side="top") - self.root.geometry(self.TkPosition) - self.root.overrideredirect(1) # fenster ohne aussen rum :-) - # self.root.attributes('-alpha', 0.7) # fenster transparent - self.root.attributes('-topmost', 1) # fenster immer im vordergrund - # self.root.wm_attributes("-disabled", True) - self.root.configure(background='black') - self.root.mainloop() - - def start_button_callback(self): - self.StartButton.configure(state=tk.DISABLED) - self.StopButton.configure(state=tk.NORMAL) - self.StatusLabel.configure(text='') - self.run_mode = 'started' - - def stop_button_callback(self): - self.StartButton.configure(state=tk.NORMAL) - self.StopButton.configure(state=tk.DISABLED) - self.run_mode = 'stopped' - - def get_run_mode(self): - return self.run_mode - - def update_status_label(self, mode, energy_to_go): - text = mode + ": " + str(energy_to_go) - self.StatusLabel.configure(text=text) diff --git a/combined_bot_main.py b/combined_bot_main.py new file mode 100644 index 0000000..a54b721 --- /dev/null +++ b/combined_bot_main.py @@ -0,0 +1,59 @@ +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 + + +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': + overlay.destroy() + 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() + +if __name__ == "__main__": + run() + sys.exit() diff --git a/combined_user_interface.py b/combined_user_interface.py new file mode 100644 index 0000000..8cd23ba --- /dev/null +++ b/combined_user_interface.py @@ -0,0 +1,235 @@ +# Run tkinter code in another thread +import threading +import tkinter as tk +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.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"] + 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.StartButton = tk.Button + self.StopButton = tk.Button + self.PauseButton = tk.Button + self.QuitButton = tk.Button + self.TkPosition = '133x239+60+600' + self.setDaemon(True) + self.StatusLabel = tk.Label + + # self.TkPosition = config.returnEnemyPlayerOverlayPos() + # + self.start() + + def run(self): + self.MiningOverlay = DiggingOverlay() + 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, 7): + 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.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.StatusLabel.grid(row=2, 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() + 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, 7): + 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, 7): + 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 or 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() + + # + 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() diff --git a/craft.py b/craft.py new file mode 100644 index 0000000..6a9b2d8 --- /dev/null +++ b/craft.py @@ -0,0 +1,316 @@ +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 + +MODE25X1 = "m25x1" +MODE10X2 = "m10x2" +MODE5X3 = "m5x3" +MODE_SIMPLE_STACK = "simple" +MODE1X5_T = "m1x5_T" +MODE1X5_X = "m1x5_X" +MODE_HOUSE = "house" + + +class Craft: + + def __init__(self, overlay): + self.overlay = overlay + self.config = UserConfigs() + + self.mode = str(overlay.emitter_use.get()) + self.run_target = int(overlay.energy_use.get()) + + self.run_counter = 0 + self.dimension = 172 + + def execute_main_loop(self): + + while True: + if self.overlay.run_mode == 'paused': + cv.waitKey(1) + continue + elif self.overlay.run_mode == 'stopped': + break + + if self.run_counter >= self.run_target: + self.run_counter = 0 + self.overlay.run_mode = 'finished' + break + + 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': + break + + 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': + break + 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': + break + + 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': + break + self.click_square_center(ab10) + elif self.mode == MODE5X3: + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + for r in range(0, 3, 1): + # grid 770 1630 160 1020 172oo + self.dimension = 172 + if r == 0: + self.click_square_center(ab1) + start = 0 + target = 1 + elif r == 1: + self.click_square_center(ab2) + start = 1 + target = 2 + else: + self.click_square_center(ab3) + 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': + break + + self.click_craft_button() + + for i in range(0, 1, 1): + if self.overlay.run_mode == 'stopped': + break + 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': + break + 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': + break + + self.click_craft_button() + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + self.click_square_center(result_tp) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + 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': + break + 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': + break + + self.click_craft_button() + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + self.click_square_center(result_tp) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + 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': + break + 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': + break + + 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': + break + + 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': + break + + 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': + break + + self.click_square_center(ab5) + self.click_square_center(tp_hammer) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + + self.click_square_center(ab6) + self.click_square_center(tp_nails) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + + self.click_craft_button() + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + + self.click_square_center(tp_result) + self.click_square_center(ab10) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + + 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': + break + 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() + # odig_overlay = DiggingOverlay(config) + check_for_craft_button(capture_window2, vision_stun, capture_config) + check_for_craft_ok_button(capture_window2, vision_stun) + 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) diff --git a/craft_table/craft_overlay.py b/craft_table/craft_overlay.py deleted file mode 100644 index b4a1a3c..0000000 --- a/craft_table/craft_overlay.py +++ /dev/null @@ -1,93 +0,0 @@ -# Run tkinter code in another thread -import threading -import tkinter as tk -from tkinter import ttk - - -class CraftOverlay(threading.Thread): - - def __init__(self): - threading.Thread.__init__(self) - - self.run_mode = 'init' - - self.root = tk.Tk - - self.crafts_use = tk.StringVar - self.mode_use = tk.StringVar - - self.CraftsLabel = tk.Label - self.CraftsEntry = tk.Entry - self.ModeLabel = tk.Label - self.Mode_Box = ttk.Combobox - self.ButtonFrame = tk.Frame - - self.StartButton = tk.Button - self.StopButton = tk.Button - self.TkPosition = '133x92+60+600' - - self.StatusLabel = tk.Label - - self.start() - - def run(self): - self.root = tk.Tk() - - self.crafts_use = tk.StringVar(self.root, value='100') - self.mode_use = tk.StringVar(self.root, value='m25x1') - - self.CraftsLabel = tk.Label(self.root, text="Crafts:", font=("Helvetica", 10, "bold"), - background="grey") - self.CraftsLabel.grid(row=0, column=0, sticky='w') - self.CraftsEntry = tk.Entry(self.root, textvariable=self.crafts_use, font=("Helvetica", 10, "bold"), width='12') - - self.CraftsEntry.grid(row=0, column=1, columnspan=2) - - self.ModeLabel = tk.Label(self.root, text="Mode:", font=("Helvetica", 10, "bold"), - background="grey") - self.ModeLabel.grid(row=2, column=0, sticky='w') - self.Mode_Box = ttk.Combobox(self.root, textvariable=self.mode_use, font=("Helvetica", 8, "bold"), - width='11') - self.Mode_Box['values'] = ('m25x1', 'm10x2', 'm5x3', 'simple', 'm1x5_T', 'm1x5_X', 'house') - - self.Mode_Box.grid(row=2, column=1, columnspan=2, sticky='w') - - self.ButtonFrame = tk.Frame(self.root) - self.StartButton = tk.Button(self.ButtonFrame, text="Start", command=self.start_button_callback, width='8') - self.StartButton.grid(row=0, column=0) - self.StopButton = tk.Button(self.ButtonFrame, text="Stop", command=self.stop_button_callback, width='8', - state=tk.DISABLED) - self.StopButton.grid(row=0, column=1) - - self.ButtonFrame.grid(row=3, column=0, columnspan=2) - - self.StatusLabel = tk.Label(self.root, text="", font=("Helvetica", 10, "bold"), - background="grey") - self.StatusLabel.grid(row=4, column=0, columnspan=2) - - # self.ClearButton.pack(side="top") - self.root.geometry(self.TkPosition) - self.root.overrideredirect(1) # fenster ohne aussen rum :-) - # self.root.attributes('-alpha', 0.7) # fenster transparent - self.root.attributes('-topmost', 1) # fenster immer im vordergrund - # self.root.wm_attributes("-disabled", True) - self.root.configure(background='black') - self.root.mainloop() - - def start_button_callback(self): - self.StartButton.configure(state=tk.DISABLED) - self.StopButton.configure(state=tk.NORMAL) - self.StatusLabel.configure(text='') - self.run_mode = 'started' - - def stop_button_callback(self): - self.StartButton.configure(state=tk.NORMAL) - self.StopButton.configure(state=tk.DISABLED) - self.run_mode = 'stopped' - - def get_run_mode(self): - return self.run_mode - - def update_status_label(self, mode, energy_to_go): - text = mode + ": " + str(energy_to_go) - self.StatusLabel.configure(text=text) diff --git a/craft_table/main_craft.py b/craft_table/main_craft.py deleted file mode 100644 index f282213..0000000 --- a/craft_table/main_craft.py +++ /dev/null @@ -1,337 +0,0 @@ -from time import time -import sys -import cv2 as cv -import keyboard -from utils import get_click_point, dig_point, check_for_craft_ok_button, check_for_craft_button -import pydirectinput -from craft_overlay import CraftOverlay -from config_file import UserConfigs -from window_capture import WindowCapture -from vision import Vision - -MODE25X1 = "m25x1" -MODE10X2 = "m10x2" -MODE5X3 = "m5x3" -MODE_SIMPLE_STACK = "simple" -MODE1X5_T = "m1x5_T" -MODE1X5_X = "m1x5_X" -MODE_HOUSE = "house" - -def run(): - overlay = CraftOverlay() - - while True: - if overlay.run_mode == 'stopped': - overlay.update_status_label("stopped", "0") - overlay.run_mode = 'init' - continue - elif overlay.run_mode == 'started': - cv.waitKey(1000) - elif overlay.run_mode == 'init': - cv.waitKey(1) - continue - elif overlay.run_mode == 'finished': - overlay.update_status_label("finished", "0") - overlay.run_mode = 'init' - continue - else: - #boelk - pass - - mode = str(overlay.mode_use.get()) - run_target = int(overlay.crafts_use.get()) - - run_counter = 0 - - while True: - if overlay.run_mode == 'stopped': - break - - if run_counter >= run_target: - run_counter = 0 - overlay.run_mode = 'finished' - break - - 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 mode == MODE25X1: - click_square_center(ab1) - - # grid 770 1630 160 1020 172 o - dim = 172 - for i in range(0, 5, 1): - for e in range(0, 5, 1): - click_square_center([770 + (i * dim), 160 + (e * dim), dim, dim]) - if overlay.run_mode == 'stopped': - break - - click_craft_button() - - for i in range(0, 5, 1): - for e in range(0, 5, 1): - collect_grid_reverse_click([770 + (i * dim), 160 + (e * dim), dim, dim]) - run_counter = run_counter + 1 - overlay.update_status_label(mode, run_target - run_counter) - if overlay.run_mode == 'stopped': - break - click_square_center(ab10) - elif mode == MODE10X2: - for r in range(0, 2, 1): - # grid 770 1630 160 1020 172 - dim = 172 - if r == 0: - click_square_center(ab1) - start = 0 - target = 3 - else: - click_square_center(ab2) - start = 1 - target = 4 - - for i in range(start, target, 2): - for e in range(0, 5, 1): - click_square_center([770 + (i * dim), 160 + (e * dim), dim, dim]) - if overlay.run_mode == 'stopped': - break - - click_craft_button() - - for i in range(0, 4, 2): - for e in range(0, 5, 1): - collect_grid_reverse_click([770 + (i * dim), 160 + (e * dim), dim, dim]) - run_counter = run_counter + 1 - overlay.update_status_label(mode, run_target - run_counter) - if overlay.run_mode == 'stopped': - break - click_square_center(ab10) - elif mode == MODE5X3: - if overlay.run_mode == 'stopped': - break - for r in range(0, 3, 1): - # grid 770 1630 160 1020 172oo - dim = 172 - if r == 0: - click_square_center(ab1) - start = 0 - target = 1 - elif r == 1: - click_square_center(ab2) - start = 1 - target = 2 - else: - click_square_center(ab3) - start = 2 - target = 3 - - for i in range(start, target, 1): - for e in range(0, 5, 1): - click_square_center([770 + (i * dim), 160 + (e * dim), dim, dim]) - if overlay.run_mode == 'stopped': - break - - click_craft_button() - - for i in range(0, 1, 1): - if overlay.run_mode == 'stopped': - break - for e in range(0, 5, 1): - collect_grid_reverse_click([770 + (i * dim), 160 + (e * dim), dim, dim]) - run_counter = run_counter + 1 - overlay.update_status_label(mode, run_target - run_counter) - if overlay.run_mode == 'stopped': - break - click_square_center(ab10) - elif mode == MODE1X5_T: - dim = 172 - - tps = [] - tps.append(ab1) - tps.append([770 + (0 * dim), 160 + (2 * dim), dim, dim]) - tps.append([770 + (1 * dim), 160 + (2 * dim), dim, dim]) - tps.append(ab2) - tps.append([770 + (2 * dim), 160 + (1 * dim), dim, dim]) - tps.append([770 + (2 * dim), 160 + (2 * dim), dim, dim]) - tps.append([770 + (2 * dim), 160 + (3 * dim), dim, dim]) - - result_tp = [770 + (0 * dim), 160 + (3 * dim), dim, dim] - - for tp in tps: - click_square_center(tp) - if overlay.run_mode == 'stopped': - break - - click_craft_button() - if overlay.run_mode == 'stopped': - break - click_square_center(result_tp) - if overlay.run_mode == 'stopped': - break - click_square_center(ab10) - - run_counter = run_counter + 1 - overlay.update_status_label(mode, run_target - run_counter) - - if overlay.run_mode == 'stopped': - break - elif mode == MODE1X5_X: - dim = 172 - - tps = [] - tps.append(ab1) - tps.append([770 + (0 * dim), 160 + (3 * dim), dim, dim]) - tps.append([770 + (1 * dim), 160 + (3 * dim), dim, dim]) - tps.append([770 + (2 * dim), 160 + (3 * dim), dim, dim]) - tps.append([770 + (1 * dim), 160 + (4 * dim), dim, dim]) - tps.append([770 + (1 * dim), 160 + (2 * dim), dim, dim]) - - result_tp = [770 + (0 * dim), 160 + (4 * dim), dim, dim] - - for tp in tps: - click_square_center(tp) - if overlay.run_mode == 'stopped': - break - - click_craft_button() - if overlay.run_mode == 'stopped': - break - click_square_center(result_tp) - if overlay.run_mode == 'stopped': - break - click_square_center(ab10) - - run_counter = run_counter + 1 - overlay.update_status_label(mode, run_target - run_counter) - - if overlay.run_mode == 'stopped': - break - elif mode == MODE_HOUSE: - dim = 172 - - cements = [] - cements.append([770 + (0 * dim), 160 + (4 * dim), dim, dim]) - cements.append([770 + (1 * dim), 160 + (4 * dim), dim, dim]) - cements.append([770 + (2 * dim), 160 + (4 * dim), dim, dim]) - cements.append([770 + (3 * dim), 160 + (4 * dim), dim, dim]) - cements.append([770 + (4 * dim), 160 + (4 * dim), dim, dim]) - - bricks = [] - bricks.append([770 + (0 * dim), 160 + (3 * dim), dim, dim]) - bricks.append([770 + (1 * dim), 160 + (3 * dim), dim, dim]) - bricks.append([770 + (3 * dim), 160 + (3 * dim), dim, dim]) - bricks.append([770 + (4 * dim), 160 + (3 * dim), dim, dim]) - bricks.append([770 + (0 * dim), 160 + (2 * dim), dim, dim]) - bricks.append([770 + (2 * dim), 160 + (2 * dim), dim, dim]) - bricks.append([770 + (4 * dim), 160 + (2 * dim), dim, dim]) - - boards = [] - boards.append([770 + (2 * dim), 160 + (3 * dim), dim, dim]) - boards.append([770 + (0 * dim), 160 + (1 * dim), dim, dim]) - boards.append([770 + (1 * dim), 160 + (1 * dim), dim, dim]) - boards.append([770 + (2 * dim), 160 + (1 * dim), dim, dim]) - boards.append([770 + (3 * dim), 160 + (1 * dim), dim, dim]) - boards.append([770 + (4 * dim), 160 + (1 * dim), dim, dim]) - boards.append([770 + (2 * dim), 160 + (0 * dim), dim, dim]) - - glasses = [] - glasses.append([770 + (1 * dim), 160 + (2 * dim), dim, dim]) - glasses.append([770 + (3 * dim), 160 + (2 * dim), dim, dim]) - - tp_hammer = [770 + (1 * dim), 160 + (0 * dim), dim, dim] - tp_nails = [770 + (3 * dim), 160 + (0 * dim), dim, dim] - tp_result = [770 + (0 * dim), 160 + (4 * dim), dim, dim] - - click_square_center(ab1) - - for cement in cements: - click_square_center(cement) - if overlay.run_mode == 'stopped': - break - - click_square_center(ab2) - - for brick in bricks: - click_square_center(brick) - if overlay.run_mode == 'stopped': - break - - click_square_center(ab3) - - for board in boards: - click_square_center(board) - if overlay.run_mode == 'stopped': - break - - click_square_center(ab4) - - for glass in glasses: - click_square_center(glass) - if overlay.run_mode == 'stopped': - break - - click_square_center(ab5) - click_square_center(tp_hammer) - if overlay.run_mode == 'stopped': - break - - click_square_center(ab6) - click_square_center(tp_nails) - if overlay.run_mode == 'stopped': - break - - click_craft_button() - if overlay.run_mode == 'stopped': - break - - click_square_center(tp_result) - click_square_center(ab10) - if overlay.run_mode == 'stopped': - break - - run_counter = run_counter + 1 - overlay.update_status_label(mode, run_target - run_counter) - - if overlay.run_mode == 'stopped': - break - elif 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() - # odig_overlay = DiggingOverlay(config) - check_for_craft_button(capture_window2, vision_stun, capture_config) - check_for_craft_ok_button(capture_window2, vision_stun) - run_counter = run_counter + 1 - overlay.update_status_label(mode, run_target - run_counter) - #check_for_ok_button(capture_window, vision_stun, capture_config) - -def collect_grid_reverse_click(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(): - dig_point(1910, 330, 100) - cv.waitKey(1500) - - -def click_square_center(square): - cp = get_click_point(square) - dig_point(cp[0], cp[1], 100) - cv.waitKey(100) - -if __name__ == "__main__": - run() - sys.exit() diff --git a/crop/crop_overlay.py b/crop/crop_overlay.py deleted file mode 100644 index fea02c8..0000000 --- a/crop/crop_overlay.py +++ /dev/null @@ -1,66 +0,0 @@ -# Run tkinter code in another thread -import threading -import tkinter as tk -from tkinter import ttk - - -class CropOverlay(threading.Thread): - - def __init__(self): - threading.Thread.__init__(self) - - self.run_mode = 'init' - - self.root = tk.Tk - - self.ButtonFrame = tk.Frame - - self.StartButton = tk.Button - self.StopButton = tk.Button - self.TkPosition = '133x52+60+600' - - self.StatusLabel = tk.Label - - self.start() - - def run(self): - self.root = tk.Tk() - self.ButtonFrame = tk.Frame(self.root) - self.StartButton = tk.Button(self.ButtonFrame, text="Start", command=self.start_button_callback, width='8') - self.StartButton.grid(row=0, column=0) - self.StopButton = tk.Button(self.ButtonFrame, text="Stop", command=self.stop_button_callback, width='8', - state=tk.DISABLED) - self.StopButton.grid(row=0, column=1) - - self.ButtonFrame.grid(row=3, column=0, columnspan=2) - - self.StatusLabel = tk.Label(self.root, text="", font=("Helvetica", 10, "bold"), - background="grey") - self.StatusLabel.grid(row=4, column=0, columnspan=2) - - # self.ClearButton.pack(side="top") - self.root.geometry(self.TkPosition) - self.root.overrideredirect(1) # fenster ohne aussen rum :-) - # self.root.attributes('-alpha', 0.7) # fenster transparent - self.root.attributes('-topmost', 1) # fenster immer im vordergrund - # self.root.wm_attributes("-disabled", True) - self.root.configure(background='black') - self.root.mainloop() - - def start_button_callback(self): - self.StartButton.configure(state=tk.DISABLED) - self.StopButton.configure(state=tk.NORMAL) - self.StatusLabel.configure(text='') - self.run_mode = 'started' - - def stop_button_callback(self): - self.StartButton.configure(state=tk.NORMAL) - self.StopButton.configure(state=tk.DISABLED) - self.run_mode = 'stopped' - - def get_run_mode(self): - return self.run_mode - - def update_status_label(self, mode, energy_to_go): - text = mode + ": " + str(energy_to_go) - self.StatusLabel.configure(text=text) diff --git a/crop/main_crop_ui.py b/crop/main_crop_ui.py deleted file mode 100644 index 8b362b4..0000000 --- a/crop/main_crop_ui.py +++ /dev/null @@ -1,36 +0,0 @@ -from Field_Representation_crop import Field -from time import time -import cv2 as cv -import keyboard -from crop_overlay import CropOverlay - - -def run(): - field = Field() - overlay = CropOverlay() - - while True: - if overlay.run_mode == 'stopped': - overlay.update_status_label("stopped", "0") - overlay.run_mode = 'init' - continue - elif overlay.run_mode == 'started': - cv.waitKey(1000) - elif overlay.run_mode == 'init': - cv.waitKey(1) - continue - else: - # boelk - pass - - while True: - if overlay.run_mode == 'stopped': - break - - cords = field.assess_playfield_and_make_move() - print(cords) - cv.waitKey(1000) - - -if __name__ == "__main__": - run() diff --git a/crop/Field_Representation_crop.py b/crops.py similarity index 81% rename from crop/Field_Representation_crop.py rename to crops.py index f43307d..e98d3ff 100644 --- a/crop/Field_Representation_crop.py +++ b/crops.py @@ -35,15 +35,19 @@ 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 Field: +class Crops: data_value_grid = [] data_coordinates = [] screenshot = [] - next_level = cv.imread("next_level.jpg", cv.IMREAD_COLOR) - next_level_x = cv.imread("next_level_x.jpg", cv.IMREAD_COLOR) - reset_board = cv.imread("reset_button.jpg", cv.IMREAD_COLOR) - reset_confirm = cv.imread("reset_confirm.jpg", cv.IMREAD_COLOR) + next_level = cv.imread("crop/next_level.jpg", cv.IMREAD_COLOR) + next_level_x = cv.imread("crop/next_level_x.jpg", cv.IMREAD_COLOR) + reset_board = cv.imread("crop/reset_button.jpg", cv.IMREAD_COLOR) + reset_confirm = cv.imread("crop/reset_confirm.jpg", cv.IMREAD_COLOR) reset_counter = 0 colors_at_standard = True needles = {} @@ -51,12 +55,15 @@ class Field: explosives = [RAINBOW, ARROW_RIGHT, ARROW_DOWN, BIGBOMB, BOMB] colors = [GREEN, YELLOW, RED, BLUE, PURPLE, MAGINENT, CHEMTRANT, TENESENT, CIBUTRANT, ARTISENT] - def __init__(self): + def __init__(self, overlay): + self.overlay = overlay self.data_value_grid = np.zeros((8, 14), dtype=int) self.data_coordinates = np.zeros((8, 14), dtype=object) self.data_score_map = np.zeros((8, 14), dtype=int) self.observation = np.zeros((8, 14), dtype=int) + self.current_strategy = RAINBOW_STRATEGY + # 230 to 2110 = 1883 / 14 = 134.5 # 60 to 1130 = 1076 / 8 = 134.5 dim = 134.5 @@ -74,28 +81,38 @@ class Field: self.set_color_order((GREEN, YELLOW, RED, BLUE, PURPLE)) + def execute_main_loop(self): + while True: + if self.overlay.run_mode == 'paused': + cv.waitKey(1) + continue + elif self.overlay.run_mode == 'stopped': + break + + self.assess_playfield_and_make_move() + def reset(self): self.observation = [] def set_color_order(self, order): self.needles.clear() - self.needles = {order[0]: cv.imread("green.jpg", cv.IMREAD_COLOR), - order[1]: cv.imread("yellow.jpg", cv.IMREAD_COLOR), - order[2]: cv.imread("red.jpg", cv.IMREAD_COLOR), - order[3]: cv.imread("blue.jpg", cv.IMREAD_COLOR), - order[4]: cv.imread("purple.jpg", cv.IMREAD_COLOR), + 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("rainbow.jpg", cv.IMREAD_COLOR), - BIGBOMB: cv.imread("bigbomb.jpg", cv.IMREAD_COLOR), - BOMB: cv.imread("bomb.jpg", cv.IMREAD_COLOR), - ARROW_DOWN: cv.imread("arrow_down.jpg", cv.IMREAD_COLOR), - ARROW_RIGHT: cv.imread("arrow_right.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("maginent.jpg", cv.IMREAD_COLOR), - CHEMTRANT: cv.imread("chemtrant.jpg", cv.IMREAD_COLOR), - TENESENT: cv.imread("tenesent.jpg", cv.IMREAD_COLOR), - CIBUTRANT: cv.imread("cibutrant.jpg", cv.IMREAD_COLOR), - ARTISENT: cv.imread("artisent.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), @@ -130,7 +147,10 @@ class Field: if self.reset_counter == 1: pass elif self.reset_counter == 2: - self.detonate_explosive_when_stuck(new_observation) + 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() @@ -140,12 +160,10 @@ class Field: if self.check_for_button_and_execute(screenshot, self.reset_confirm): cv.waitKey(500) - if self.colors_at_standard: - self.set_color_order((PURPLE, BLUE, RED, YELLOW, GREEN)) - self.colors_at_standard = False - else: - self.set_color_order((GREEN, YELLOW, RED, BLUE, PURPLE)) - self.colors_at_standard = True + 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: @@ -199,6 +217,8 @@ class Field: 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[58:1134, 230:2113] @@ -244,10 +264,10 @@ class Field: 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) + #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 @@ -256,22 +276,26 @@ class Field: for i in range(0, 14, 1): for explosive in self.explosives: if self.local_pos_check(state, e, i, 0, 0, explosive): - dest_pt = self.get_click_point(self.data_coordinates[e, i]) + src_pt = self.get_click_point(self.data_coordinates[e, i]) if self.local_pos_checks(state, e, i, 1, 0, self.colors): - src_pt = self.get_click_point(self.data_coordinates[e + 1, i]) + dest_pt = self.get_click_point(self.data_coordinates[e + 1, i]) self.move_tile(src_pt, dest_pt) + return True elif self.local_pos_checks(state, e, i, 0, 1, self.colors): - src_pt = self.get_click_point(self.data_coordinates[e, i + 1]) + dest_pt = self.get_click_point(self.data_coordinates[e, i + 1]) self.move_tile(src_pt, dest_pt) + return True elif self.local_pos_checks(state, e, i, -1, 0, self.colors): - src_pt = self.get_click_point(self.data_coordinates[e - 1, i]) + dest_pt = self.get_click_point(self.data_coordinates[e - 1, i]) self.move_tile(src_pt, dest_pt) + return True elif self.local_pos_checks(state, e, i, 0, -1, self.colors): - src_pt = self.get_click_point(self.data_coordinates[e, i - 1]) + dest_pt = self.get_click_point(self.data_coordinates[e, i - 1]) self.move_tile(src_pt, dest_pt) + return True else: continue - return + return False def check_explosives(self, state, e, i): for explosive in self.explosives: @@ -302,6 +326,10 @@ class Field: 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': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break full_moves = [] reserve_moves = [] @@ -318,11 +346,19 @@ class Field: 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': + break 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': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break # print(self.data_score_map) # screenshot = cv.imread("screenshot_scored.jpg") @@ -331,19 +367,16 @@ class Field: 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]) >= 10: - self.print_move(full_dic[key]) + if len(full_dic[key]) >= self.current_strategy: + #self.print_move(full_dic[key]) self.execute_move(full_dic[key]) - break + return if len(reserve_moves) >= 1: for key in sorted(res_dic): - self.print_move(res_dic[key]) + #self.print_move(res_dic[key]) self.execute_move(res_dic[key]) break @@ -429,6 +462,8 @@ class Field: 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 @@ -460,7 +495,8 @@ class Field: 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 diff --git a/digging_main2.py b/digging_main2.py deleted file mode 100644 index 1c2bf2a..0000000 --- a/digging_main2.py +++ /dev/null @@ -1,202 +0,0 @@ -import sys - -from config_file import UserConfigs -import keyboard -import cv2 as cv -from utils import dig_point, check_for_ok_button -from window_capture import WindowCapture -from vision import Vision -from dig_overlay import DiggingOverlay - - -def run(): - # initialize the user-class - config = UserConfigs() - # initialize the StunWindowCapture class - capture_config = UserConfigs() - capture_window = WindowCapture(None, "screen_conf", capture_config) - - # initialize the StunVision class - vision_stun = Vision() - dig_overlay = DiggingOverlay(config) - - pause = True - level = 1 - - width = 32 - depth = 24 - plot_size = 45 - DIG_TIME = 100 - - runcounter = 2 - - if runcounter == 2: - double_dig = True - else: - double_dig = False - - while runcounter != 0: - if double_dig and runcounter == 1: - dig_point(290, 100, 200) - level = 1 - plot_size = 45 - DIG_TIME = 100 - cv.waitKey(2000) - runcounter = runcounter - 1 - - while True: - if keyboard.is_pressed('p') == True: - pause = True - print('q pressed') - elif keyboard.is_pressed('o') == True: - pause = False - print('o pressed') - if pause: - # cv.waitKey(500) - dig_overlay.show_window() - print("pausing") - continue - dig_overlay.hide_window() - - if level >= 28: - break - if level == 23: - DIG_TIME = 800 - if level == 26: - DIG_TIME = 1800 - if level <= 10: - plot_size = plot_size - 1 - elif level % 2 == 0: - plot_size = plot_size - 1 - - p1 = int((config.returnDiggingWindowPos2()[0] / 2) + config.returnDiggingWindowPos2()[2]) - p2 = int((config.returnDiggingWindowPos2()[1] / 2) + config.returnDiggingWindowPos2()[3]) - - # start 705 , 564 -> click - # move L D -> click - # move U , U , R, R , D , D , L , L - # move L D - # move U , U , U , U , R, R , R, R, D, D, D, D, L, L, L , L - dig_point(p1, p2, DIG_TIME) - # cv.circle(screenshot, (p1, p2), 7, (0, 255, 0), -1) - i = 0 - for e in range(2, width, 2): - i = i + 1 - - tp1 = p1 - (i * plot_size) - tp2 = p2 + (i * plot_size) - for f in range(0, e, 1): - # up click - tp2 = tp2 - plot_size - if tp2 >= config.returnDiggingWindowPos2()[1] + (plot_size / 2): - continue - if tp2 <= config.returnDiggingWindowPos2()[3] + (plot_size / 2): - continue - ''' - x = int(tp1 - (plot_size / 2)) - y = int(tp2 - ((e * plot_size) - (plot_size / 2))) - w = plot_size - h = plot_size * e - - capture_win_lanes = WindowCapture(None, "lanes", None, (w, h, x+w, y+h)) - screenshot = capture_win_lanes.get_screenshot() - needlew = cv.imread("test1.jpg", cv.IMREAD_UNCHANGED) - res = vision_stun.find(needlew, screenshot, 0.9, 1) - if len(res) >= 1: - break - #vision_stun.draw_rectangles(needlew, res) - #cv.imshow("screenshot", needlew) - #cv.waitKey(150) - - - # ul[0], ul[1], plot_size, plotsize*e - - # ll -> tp1 - plot/2 ooooooooooo - # -> tp2 + plot/2 - # ul -> tp1 - plot/2 - # -> tp2 - e*plot - plot/2 - # lr -> tp1 + plot/2 - # -> tp2 - plot/2 - # ur -> tp1 + plot/2 - # -> tp2 - e*plot - plot/2 - ''' - dig_point(tp1, tp2, DIG_TIME) - # cv.circle(screenshot, (tp1, tp2), 7, (255, 0, 255), -1) - # cv.imshow("screenshot", screenshot) - # cv.waitKey(150) - check_for_ok_button(capture_window, vision_stun, capture_config) - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - - tp1 = p1 - (i * plot_size) - tp2 = p2 - (i * plot_size) - for g in range(0, e, 1): - # right click - tp1 = tp1 + plot_size - if tp2 <= config.returnDiggingWindowPos2()[3] + (plot_size / 2): - continue - - # ll -> tp1 - plot/2 - # -> tp2 + plot/2 - # ul -> tp1 - plot/2 - # -> tp2 - plot/2 - # lr -> tp1 + e*plot + plot/2 - # -> tp2 + plot/2 - # ur -> tp1 + e*plot + plot/2 - # -> tp2 - plot/2 - - dig_point(tp1, tp2, DIG_TIME) - # cv.circle(screenshot, (tp1, tp2), 7, (127, 0, 255), -1) - # cv.imshow("screenshot", screenshot) - # cv.waitKey(150) - check_for_ok_button(capture_window, vision_stun, capture_config) - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - - tp1 = p1 + (i * plot_size) - tp2 = p2 - (i * plot_size) - for r in range(0, e, 1): - # down click - tp2 = tp2 + plot_size - if tp2 >= config.returnDiggingWindowPos2()[1] + (plot_size / 2): - continue - if tp2 <= config.returnDiggingWindowPos2()[3] + (plot_size / 2): - continue - dig_point(tp1, tp2, DIG_TIME) - # cv.circle(screenshot, (tp1, tp2), 7, (255, 0, 127), -1) - # cv.imshow("screenshot", screenshot) - # cv.waitKey(150) - check_for_ok_button(capture_window, vision_stun, capture_config) - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - - tp1 = p1 + (i * plot_size) - tp2 = p2 + (i * plot_size) - for u in range(0, e, 1): - # left click - tp1 = tp1 - plot_size - if tp2 >= config.returnDiggingWindowPos2()[1] + (plot_size / 2): - continue - dig_point(tp1, tp2, DIG_TIME) - # cv.circle(screenshot, (tp1, tp2), 7, (0, 0, 255), -1) - # cv.imshow("screenshot", screenshot) - # cv.waitKey(150) - check_for_ok_button(capture_window, vision_stun, capture_config) - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - level = level + 1 - - -if __name__ == "__main__": - run() - sys.exit() diff --git a/equipment.py b/equipment.py new file mode 100644 index 0000000..8e0ebd0 --- /dev/null +++ b/equipment.py @@ -0,0 +1,728 @@ +import random +from operator import itemgetter +from time import time +from window_capture import WindowCapture +from vision import Vision +import cv2 as cv +from hsvfilter import HsvFilter +from config_file import UserConfigs +import pydirectinput +from utils import dig_point + +EMITTER_MAIN = "main" +EMITTER_MUSH = "mushroom" +EMITTER_AMU = "amulett" +EMITTER_SWORD = "sword" +EMITTER_STAFF = "staff" +EMITTER_WAND = "wand" +EMITTER_RING = "ring" +EMITTER_MULTI = "multi" + +HSV_DEFAULT = HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0) + + +class Equipment: + needles = [] + hsvs = [] + tresholds = [] + masks = [] + emitters = [] + + def __init__(self, overlay): + self.overlay = overlay + self.config = UserConfigs() + + self.EMITTER_TO_USE = str(overlay.emitter_use.get()) + self.SPAWN_COUNT = int(overlay.spawn_use.get()) + self.ENERGY_TO_USE = int(overlay.energy_use.get()) + + # initialize the StunWindowCapture class + self.capture_window = WindowCapture(None, "equip", self.config) + + # initialize the StunVision class + self.vision_stun = Vision() + + if self.EMITTER_TO_USE == EMITTER_MULTI: + self.emitters.append(EMITTER_RING) + self.emitters.append(EMITTER_WAND) + self.emitters.append(EMITTER_SWORD) + self.emitters.append(EMITTER_AMU) + self.emitters.append(EMITTER_STAFF) + else: + self.emitters.append(self.EMITTER_TO_USE) + + for emitter in self.emitters: + if emitter == EMITTER_MUSH: + self.include_books() + self.include_mushs() + self.include_pots() + self.include_bags() + elif emitter == EMITTER_AMU: + self.include_books() + self.include_amus() + self.include_bags() + elif emitter == EMITTER_MAIN: + self.include_books() + self.include_chests() + self.include_keys() + self.include_pots() + self.include_bags() + self.include_coins() + self.include_runes() + elif emitter == EMITTER_SWORD: + self.include_books() + self.include_swords() + self.include_bags() + elif emitter == EMITTER_STAFF: + self.include_books() + self.include_staffs() + self.include_bags() + elif emitter == EMITTER_RING: + self.include_books() + self.include_rings() + self.include_bags() + elif emitter == EMITTER_WAND: + self.include_books() + self.include_wands() + self.include_bags() + + self.c_needle = cv.imread("equip/chests/chest_4_32.jpg", cv.IMREAD_UNCHANGED) + self.c_mask = cv.imread("equip/chests/chest_4_32-mask.png", cv.IMREAD_COLOR) + self.k_needle = cv.imread("equip/keys/key_4_32.jpg", cv.IMREAD_UNCHANGED) + self.k_mask = cv.imread("equip/keys/key_4_32-mask.png", cv.IMREAD_COLOR) + self.dig_button = cv.imread("dig/ok_button.jpg", cv.IMREAD_UNCHANGED) + + self.energy_counter = 0 + + def execute_main_loop(self): + for emitter in self.emitters: + while True: + if self.overlay.run_mode == 'paused': + cv.waitKey(1) + continue + elif self.overlay.run_mode == 'stopped': + break + + # get an updated image of the game + screenshot = self.capture_window.get_screenshot() + + # cv.imshow("screenshot", screenshot) + # cv.waitKey(150) + # continue + if self.energy_counter >= self.ENERGY_TO_USE: + self.energy_counter = 0 + break + + spawn_1 = self.find_emitter(emitter, screenshot, 1) + if len(spawn_1) == 1: + points = self.vision_stun.get_click_points(spawn_1) + for i in range(0, self.SPAWN_COUNT, 1): + self.click_point(points[0][0], points[0][1]) + self.energy_counter = self.energy_counter + 1 + self.overlay.update_status_label(emitter + ": " + str(self.ENERGY_TO_USE - self.energy_counter)) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + else: + spawn_0 = self.find_emitter(emitter, screenshot, 0) + points = self.vision_stun.get_click_points(spawn_0) + for point in points: + self.click_point(points[0][0], points[0][1]) + + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + continue + + cv.waitKey(500) + + if emitter == EMITTER_MAIN: + while True: + screenshot = self.capture_window.get_screenshot() + c_rectangles = self.vision_stun.find(screenshot, self.c_needle, 0.95, 1, True, self.c_mask) + k_rectangles = self.vision_stun.find(screenshot, self.k_needle, 0.95, 1, True, self.k_mask) + if (len(c_rectangles) == 1) and (len(k_rectangles) == 1): + c_point = self.vision_stun.get_click_points(c_rectangles)[0] + k_point = self.vision_stun.get_click_points(k_rectangles)[0] + self.move_tile(k_point, c_point) + else: + break + + for rer in range(0, len(self.needles), 1): + loop_time = time() + while True: + if (time() - loop_time) >= 60: + break + screenshot = self.capture_window.get_screenshot_by_area(self.config.returnOKWindowPos()) + rectangles = self.vision_stun.find(screenshot, self.dig_button, 0.5, 1) + if len(rectangles) == 1: + pointis = self.vision_stun.get_click_points(rectangles) + for pointi in pointis: + dig_point(pointi[0] + self.config.returnOKWindowPos()[2], + pointi[1] + self.config.returnOKWindowPos()[3], 150) + cv.waitKey(60000) + continue + # do object detection + screenshot = self.capture_window.get_screenshot() + # processed_screenshot = self.vision_stun.apply_hsv_filter(screenshot, self.hsvs[rer]) + # processed_needle = self.vision_stun.apply_hsv_filter(self.needles[rer], self.hsvs[rer]) + + rectangles = self.vision_stun.find_by_mask_and_validate(screenshot, self.needles[rer], + self.masks[rer], 5) + # draw the detection results onto the original image + # output_image = self.vision_stun.draw_rectangles(screenshot, rectangles) + # cv.imshow("output_image", output_image) + # cv.waitKey(150) + + if len(rectangles) is not 5: + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + + # sort rectangles by top + rectangles = sorted(rectangles, key=itemgetter(1)) + + points = self.vision_stun.get_click_points(rectangles) + + move_breaker = self.check_and_move_tile([70, 70, rectangles[0][0] + 70, rectangles[0][1]], + self.needles[rer], + points[1], [points[0][0] + 70, points[0][1]]) + if move_breaker: + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + move_breaker = self.check_and_move_tile([70, 70, rectangles[0][0], rectangles[0][1] + 70], + self.needles[rer], + points[2], [points[0][0], points[0][1] + 70]) + if move_breaker: + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + move_breaker = self.check_and_move_tile([70, 70, rectangles[0][0] + 70, rectangles[0][1] + 70], + self.needles[rer], + points[3], [points[0][0] + 70, points[0][1] + 70]) + if move_breaker: + break + self.move_tile(points[4], [points[0][0], points[0][1]]) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + cv.waitKey(150) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped': + break + self.overlay.run_mode = 'finished' + + def check_and_move_tile(self, rect, needl, point_source, point_dest): + screenshot_p = self.capture_window.get_screenshot() + screenshot_p_w = screenshot_p.shape[1] + screenshot_p_h = screenshot_p.shape[0] + w = rect[0] + h = rect[1] + x = rect[2] + y = rect[3] + if h >= screenshot_p_h or w >= screenshot_p_w: + return True + + screenshot_pos = screenshot_p[y:y + h, x:x + w] # (w, h, x+w, y+h) + # processed_screenshot = visio.apply_hsv_filter(screenshot_pos, hsv) + # processed_needle = visio.apply_hsv_filter(needl, hsv) + result2 = cv.matchTemplate(screenshot_pos, needl, cv.TM_CCOEFF_NORMED) + _min_val2, _max_val2, min_loc2, max_loc2 = cv.minMaxLoc(result2, None) + # rectangles2 = visio.find(screenshot_pos, needl, tresh, 1, True, mask) + # output_by_area = self.vision_stun.draw_rectangles(screenshot_pos2, rectangles) + # cv.imshow("output_image_by_area", screenshot_pos) + # cv.waitKey(150) + # print("thresh in movecheck:" + str(_maxVal2)) + if _max_val2 <= 0.9: + self.move_tile(point_source, point_dest) + + return False + + def click_point(self, x, y): + offset_left = self.config.returnEquipmentWindowPos()[2] + offset_down = self.config.returnEquipmentWindowPos()[3] + pydirectinput.moveTo(x + offset_left, y + offset_down) + pydirectinput.mouseDown() + w = random.randint(1, 50) + cv.waitKey(30 + w) + pydirectinput.mouseUp() + + def move_tile(self, point_source, point_dest): + offset_left = self.config.returnEquipmentWindowPos()[2] + offset_down = self.config.returnEquipmentWindowPos()[3] + pydirectinput.moveTo(point_source[0] + offset_left, point_source[1] + offset_down) + pydirectinput.mouseDown() + w = random.randint(25, 50) + cv.waitKey(100 + w) + pydirectinput.moveTo(point_dest[0] + offset_left, point_dest[1] + offset_down) + pydirectinput.mouseUp() + cv.waitKey(400 + w) + + def find_emitter(self, emitter_to_use, screen, layer): + if self.EMITTER_TO_USE == EMITTER_MUSH: + if layer == 0: + needle = cv.imread("equip/emitters/mush_e_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/mush_e_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + else: + needle = cv.imread("equip/emitters/mush_e2_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/mush_e2_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.98, 1, True, mask) + elif emitter_to_use == EMITTER_AMU: + if layer == 0: + needle = cv.imread("equip/emitters/amu_e_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/amu_e_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + else: + needle = cv.imread("equip/emitters/amu_e2_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/amu_e2_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + elif emitter_to_use == EMITTER_MAIN: + if layer == 0: + needle = cv.imread("equip/emitters/main_e1_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/main_e1_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + else: + needle = cv.imread("equip/emitters/main_e2_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/main_e2_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + elif emitter_to_use == EMITTER_SWORD: + if layer == 0: + needle = cv.imread("equip/emitters/sword_e1_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/sword_e1_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + else: + needle = cv.imread("equip/emitters/sword_e2_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/sword_e2_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.98, 1, True, mask) + elif emitter_to_use == EMITTER_STAFF: + if layer == 0: + needle = cv.imread("equip/emitters/staff_e1_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/staff_e1_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + else: + needle = cv.imread("equip/emitters/staff_e2_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/staff_e2_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.99, 1, True, mask) + elif emitter_to_use == EMITTER_RING: + if layer == 0: + needle = cv.imread("equip/emitters/ring_e1_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/ring_e1_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + else: + needle = cv.imread("equip/emitters/ring_e2_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/ring_e2_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + elif emitter_to_use == EMITTER_WAND: + if layer == 0: + needle = cv.imread("equip/emitters/wand_e1_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/wand_e1_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.95, 1, True, mask) + else: + needle = cv.imread("equip/emitters/wand_e2_32.jpg", cv.IMREAD_UNCHANGED) + mask = cv.imread("equip/emitters/wand_e2_32-mask.png", cv.IMREAD_COLOR) + return self.vision_stun.find(screen, needle, 0.96, 1, True, mask) + + def include_chests(self): + self.needles.append(cv.imread("equip/chests/chest_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.95) + self.masks.append(cv.imread("equip/chests/chest_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/chests/chest_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.95) + self.masks.append(cv.imread("equip/chests/chest_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/chests/chest_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/chests/chest_3_32-mask.png", cv.IMREAD_COLOR)) + + def include_books(self): + self.needles.append(cv.imread("equip/books/book_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/books/book_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/books/book_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.9) + self.masks.append(cv.imread("equip/books/book_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/books/book_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.87) + self.masks.append(cv.imread("equip/books/book_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/books/book_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/books/book_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/books/book_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/books/book_5_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/books/book_6_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.9) + self.masks.append(cv.imread("equip/books/book_6_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/books/book_7_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/books/book_7_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/books/book_8_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/books/book_8_32-mask.png", cv.IMREAD_COLOR)) + + def include_keys(self): + self.needles.append(cv.imread("equip/keys/key_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/keys/key_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/keys/key_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/keys/key_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/keys/key_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/keys/key_3_32-mask.png", cv.IMREAD_COLOR)) + + def include_pots(self): + self.needles.append(cv.imread("equip/pots/pot_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/pots/pot_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/pots/pot_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/pots/pot_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/pots/pot_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.94) + self.masks.append(cv.imread("equip/pots/pot_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/pots/pot_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/pots/pot_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/pots/pot_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/pots/pot_5_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/pots/pot_6_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/pots/pot_6_32-mask.png", cv.IMREAD_COLOR)) + + def include_bags(self): + self.needles.append(cv.imread("equip/bags/bag_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/bags/bag_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/bags/bag_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.88) + self.masks.append(cv.imread("equip/bags/bag_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/bags/bag_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/bags/bag_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/bags/bag_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/bags/bag_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/bags/bag_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/bags/bag_5_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/bags/bag_6_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/bags/bag_6_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/bags/bag_7_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/bags/bag_7_32-mask.png", cv.IMREAD_COLOR)) + + def include_coins(self): + self.needles.append(cv.imread("equip/coins/coin_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/coins/coin_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/coins/coin_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/coins/coin_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/coins/coin_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/coins/coin_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/coins/coin_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/coins/coin_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/coins/coin_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/coins/coin_5_32-mask.png", cv.IMREAD_COLOR)) + + def include_runes(self): + self.needles.append(cv.imread("equip/runes/rune_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/runes/rune_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/runes/rune_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/runes/rune_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/runes/rune_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/runes/rune_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/runes/rune_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/runes/rune_4_32-mask.png", cv.IMREAD_COLOR)) + + def include_mushs(self): + self.needles.append(cv.imread("equip/mushrooms/mush_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/mushrooms/mush_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/mushrooms/mush_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/mushrooms/mush_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/mushrooms/mush_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/mushrooms/mush_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/mushrooms/mush_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/mushrooms/mush_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/mushrooms/mush_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/mushrooms/mush_5_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/mushrooms/mush_6_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/mushrooms/mush_6_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/mushrooms/mush_7_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/mushrooms/mush_7_32-mask.png", cv.IMREAD_COLOR)) + + def include_amus(self): + self.needles.append(cv.imread("equip/amus/amu_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.9) + self.masks.append(cv.imread("equip/amus/amu_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/amus/amu_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.9) + self.masks.append(cv.imread("equip/amus/amu_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/amus/amu_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/amus/amu_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/amus/amu_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/amus/amu_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/amus/amu_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/amus/amu_5_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/amus/amu_6_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/amus/amu_6_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/amus/amu_7_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/amus/amu_7_32-mask.png", cv.IMREAD_COLOR)) + + def include_swords(self): + self.needles.append(cv.imread("equip/swords/sword_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/swords/sword_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/swords/sword_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/swords/sword_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/swords/sword_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/swords/sword_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/swords/sword_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/swords/sword_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/swords/sword_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/swords/sword_5_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/swords/sword_6_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/swords/sword_6_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/swords/sword_7_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/swords/sword_7_32-mask.png", cv.IMREAD_COLOR)) + + def include_staffs(self): + self.needles.append(cv.imread("equip/staffs/staff_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/staffs/staff_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/staffs/staff_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/staffs/staff_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/staffs/staff_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/staffs/staff_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/staffs/staff_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/staffs/staff_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/staffs/staff_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/staffs/staff_5_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/staffs/staff_6_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/staffs/staff_6_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/staffs/staff_7_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/staffs/staff_7_32-mask.png", cv.IMREAD_COLOR)) + + def include_rings(self): + self.needles.append(cv.imread("equip/rings/ring_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.925) + self.masks.append(cv.imread("equip/rings/ring_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/rings/ring_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.94) + self.masks.append(cv.imread("equip/rings/ring_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/rings/ring_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/rings/ring_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/rings/ring_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/rings/ring_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/rings/ring_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/rings/ring_5_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/rings/ring_6_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.91) + self.masks.append(cv.imread("equip/rings/ring_6_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/rings/ring_7_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/rings/ring_7_32-mask.png", cv.IMREAD_COLOR)) + + def include_wands(self): + self.needles.append(cv.imread("equip/wands/wand_1_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/wands/wand_1_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/wands/wand_2_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/wands/wand_2_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/wands/wand_3_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/wands/wand_3_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/wands/wand_4_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/wands/wand_4_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/wands/wand_5_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/wands/wand_5_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/wands/wand_6_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/wands/wand_6_32-mask.png", cv.IMREAD_COLOR)) + + self.needles.append(cv.imread("equip/wands/wand_7_32.jpg", cv.IMREAD_UNCHANGED)) + self.hsvs.append(HSV_DEFAULT) + self.tresholds.append(0.93) + self.masks.append(cv.imread("equip/wands/wand_7_32-mask.png", cv.IMREAD_COLOR)) diff --git a/equipment_main.py b/equipment_main.py deleted file mode 100644 index 29c34d3..0000000 --- a/equipment_main.py +++ /dev/null @@ -1,769 +0,0 @@ -import random -from operator import itemgetter -from time import time -from window_capture import WindowCapture -from vision import Vision -import cv2 as cv -from hsvfilter import HsvFilter -from config_file import UserConfigs -import pydirectinput -import keyboard -from utils import dig_point - -EMITTER_MAIN = "main" -EMITTER_MUSH = "mushroom" -EMITTER_AMU = "amulett" -EMITTER_SWORD = "sword" -EMITTER_STAFF = "staff" -EMITTER_WAND = "wand" -EMITTER_RING = "ring" -EMITTER_MULTI = "all" - -HSV_DEFAULT = HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0) - - -def run(): - EMITTER_TO_USE = EMITTER_MULTI - SPAWN_COUNT = 25 - ENERGY_TO_USE = 3000 - # initialize the user-class - config = UserConfigs() - - # initialize the StunWindowCapture class - try: - capture_window = WindowCapture( - None, "equip", config) - except: - # StunWindowCapture.list_window_names() - print("Game not running, exiting") - # capture_window = cv.VideoCapture("snip_slam.mp4") - return - - # initialize the StunVision class - vision_stun = Vision() - - outer_loop_time = time() - - needles = [] - hsvs = [] - tresholds = [] - masks = [] - emitters = [] - - if EMITTER_TO_USE == EMITTER_MULTI: - emitters.append(EMITTER_RING) - emitters.append(EMITTER_WAND) - emitters.append(EMITTER_SWORD) - emitters.append(EMITTER_STAFF) - emitters.append(EMITTER_AMU) - else: - emitters.append(EMITTER_TO_USE) - - energy_counter = 0 - pause = True - for emitter in emitters: - if emitter == EMITTER_MUSH: - include_books(needles, hsvs, tresholds, masks) - include_mushs(needles, hsvs, tresholds, masks) - include_pots(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_AMU: - include_books(needles, hsvs, tresholds, masks) - include_amus(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_MAIN: - include_books(needles, hsvs, tresholds, masks) - include_chests(needles, hsvs, tresholds, masks) - include_keys(needles, hsvs, tresholds, masks) - include_pots(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - include_coins(needles, hsvs, tresholds, masks) - include_runes(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_SWORD: - include_books(needles, hsvs, tresholds, masks) - include_swords(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_STAFF: - include_books(needles, hsvs, tresholds, masks) - include_staffs(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_RING: - include_books(needles, hsvs, tresholds, masks) - include_rings(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_WAND: - include_books(needles, hsvs, tresholds, masks) - include_wands(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - - c_needle = cv.imread("equip/chests/chest_4_32.jpg", cv.IMREAD_UNCHANGED) - c_mask = cv.imread("equip/chests/chest_4_32-mask.png", cv.IMREAD_COLOR) - k_needle = cv.imread("equip/keys/key_4_32.jpg", cv.IMREAD_UNCHANGED) - k_mask = cv.imread("equip/keys/key_4_32-mask.png", cv.IMREAD_COLOR) - dig_button = cv.imread("dig/ok_button.jpg", cv.IMREAD_UNCHANGED) - loop_time_p = time() - - while True: - if keyboard.is_pressed('p') == True: - pause = True - print('q pressed') - elif keyboard.is_pressed('o') == True: - pause = False - print('o pressed') - - if pause: - # cv.waitKey(500) - if (time() - loop_time_p) >= 5: - loop_time_p = time() - print("pausing") - continue - - try: - # get an updated image of the game - screenshot = capture_window.get_screenshot() - # screenshot = cv.imread("buffbar.jpg") - except: - capture_window.release() - print("Game window not available - shutting down application") - break - # cv.imshow("screenshot", screenshot) - # cv.waitKey(150) - # continue - if energy_counter >= ENERGY_TO_USE: - energy_counter = 0 - break - - spawn_1 = find_emitter(emitter, vision_stun, screenshot, 1) - if len(spawn_1) == 1: - spawn_button_active = True - points = vision_stun.get_click_points(spawn_1) - for i in range(0, SPAWN_COUNT, 1): - click_point(config, points[0][0], points[0][1]) - energy_counter = energy_counter + 1 - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - else: - spawn_0 = find_emitter(emitter, vision_stun, screenshot, 0) - points = vision_stun.get_click_points(spawn_0) - for point in points: - click_point(config, points[0][0], points[0][1]) - - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - continue - - cv.waitKey(500) - - if emitter == EMITTER_MAIN: - while True: - screenshot = capture_window.get_screenshot() - c_rectangles = vision_stun.find(screenshot, c_needle, 0.95, 1, True, c_mask) - k_rectangles = vision_stun.find(screenshot, k_needle, 0.95, 1, True, k_mask) - if (len(c_rectangles) == 1) and (len(k_rectangles) == 1): - c_point = vision_stun.get_click_points(c_rectangles)[0] - k_point = vision_stun.get_click_points(k_rectangles)[0] - move_tile(config, k_point, c_point) - else: - break - - for rer in range(0, len(needles), 1): - loop_time = time() - while True: - if (time() - loop_time) >= 60: - break - screenshot = capture_window.get_screenshot_by_area(config.returnOKWindowPos()) - rectangles = vision_stun.find(screenshot, dig_button, 0.5, 1) - if len(rectangles) == 1: - pointis = vision_stun.get_click_points(rectangles) - for pointi in pointis: - dig_point(pointi[0] + config.returnOKWindowPos()[2], - pointi[1] + config.returnOKWindowPos()[3], 150) - cv.waitKey(60000) - continue - # do object detection - screenshot = capture_window.get_screenshot() - # processed_screenshot = vision_stun.apply_hsv_filter(screenshot, hsvs[rer]) - # processed_needle = vision_stun.apply_hsv_filter(needles[rer], hsvs[rer]) - - rectangles = vision_stun.find_by_mask_and_validate(screenshot, needles[rer], masks[rer], 5) - # draw the detection results onto the original image - # output_image = vision_stun.draw_rectangles(screenshot, rectangles) - # cv.imshow("output_image", output_image) - # cv.waitKey(150) - - if len(rectangles) is not 5: - break - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - - # sort rectangles by top - rectangles = sorted(rectangles, key=itemgetter(1)) - - points = vision_stun.get_click_points(rectangles) - - move_breaker = check_and_move_tile(capture_window, vision_stun, config, - [70, 70, rectangles[0][0] + 70, rectangles[0][1]], needles[rer], - hsvs[rer], tresholds[rer], masks[rer], - points[1], [points[0][0] + 70, points[0][1]]) - if move_breaker: - break - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - move_breaker = check_and_move_tile(capture_window, vision_stun, config, - [70, 70, rectangles[0][0], rectangles[0][1] + 70], needles[rer], - hsvs[rer], tresholds[rer], masks[rer], - points[2], [points[0][0], points[0][1] + 70]) - if move_breaker: - break - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - move_breaker = check_and_move_tile(capture_window, vision_stun, config, - [70, 70, rectangles[0][0] + 70, rectangles[0][1] + 70], - needles[rer], hsvs[rer], tresholds[rer], masks[rer], - points[3], [points[0][0] + 70, points[0][1] + 70]) - if move_breaker: - break - move_tile(config, points[4], [points[0][0], points[0][1]]) - if keyboard.is_pressed('p') == True or pause == True: - pause = True - break - # debug the loop rate - print('FPS {}'.format(1 / (time() - outer_loop_time))) - outer_loop_time = time() - cv.waitKey(150) - - -def check_and_move_tile(capture_win, visio, conf, rect, needl, hsv, tresh, mask, point_source, point_dest): - screenshot_p = capture_win.get_screenshot() - screenshot_p_w = screenshot_p.shape[1] - screenshot_p_h = screenshot_p.shape[0] - w = rect[0] - h = rect[1] - x = rect[2] - y = rect[3] - if h >= screenshot_p_h or w >= screenshot_p_w: - return True - - screenshot_pos = screenshot_p[y:y + h, x:x + w] # (w, h, x+w, y+h) - # processed_screenshot = visio.apply_hsv_filter(screenshot_pos, hsv) - # processed_needle = visio.apply_hsv_filter(needl, hsv) - result2 = cv.matchTemplate(screenshot_pos, needl, cv.TM_CCOEFF_NORMED) - _minVal2, _maxVal2, minLoc2, maxLoc2 = cv.minMaxLoc(result2, None) - # rectangles2 = visio.find(screenshot_pos, needl, tresh, 1, True, mask) - # output_by_area = vision_stun.draw_rectangles(screenshot_pos2, rectangles) - # cv.imshow("output_image_by_area", screenshot_pos) - # cv.waitKey(150) - # print("thresh in movecheck:" + str(_maxVal2)) - if _maxVal2 <= 0.9: - move_tile(conf, point_source, point_dest) - - return False - - -def click_point(conf, x, y): - offset_left = conf.returnEquipmentWindowPos()[2] - offset_down = conf.returnEquipmentWindowPos()[3] - pydirectinput.moveTo(x + offset_left, y + offset_down) - pydirectinput.mouseDown() - w = random.randint(1, 50) - cv.waitKey(30 + w) - pydirectinput.mouseUp() - - -def move_tile(conf, point_source, point_dest): - offset_left = conf.returnEquipmentWindowPos()[2] - offset_down = conf.returnEquipmentWindowPos()[3] - pydirectinput.moveTo(point_source[0] + offset_left, point_source[1] + offset_down) - pydirectinput.mouseDown() - w = random.randint(25, 50) - cv.waitKey(100 + w) - pydirectinput.moveTo(point_dest[0] + offset_left, point_dest[1] + offset_down) - pydirectinput.mouseUp() - cv.waitKey(400 + w) - - -def find_emitter(emitter_to_use, vis, screen, layer): - if emitter_to_use == EMITTER_MUSH: - if layer == 0: - needle = cv.imread("equip/emitters/mush_e_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/mush_e_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/mush_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/mush_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.98, 1, True, mask) - elif emitter_to_use == EMITTER_AMU: - if layer == 0: - needle = cv.imread("equip/emitters/amu_e_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/amu_e_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/amu_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/amu_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - elif emitter_to_use == EMITTER_MAIN: - if layer == 0: - needle = cv.imread("equip/emitters/main_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/main_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/main_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/main_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - elif emitter_to_use == EMITTER_SWORD: - if layer == 0: - needle = cv.imread("equip/emitters/sword_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/sword_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/sword_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/sword_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.98, 1, True, mask) - elif emitter_to_use == EMITTER_STAFF: - if layer == 0: - needle = cv.imread("equip/emitters/staff_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/staff_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/staff_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/staff_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.99, 1, True, mask) - elif emitter_to_use == EMITTER_RING: - if layer == 0: - needle = cv.imread("equip/emitters/ring_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/ring_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/ring_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/ring_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - elif emitter_to_use == EMITTER_WAND: - if layer == 0: - needle = cv.imread("equip/emitters/wand_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/wand_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/wand_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/wand_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.96, 1, True, mask) - - -def include_chests(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/chests/chest_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.95) - mask.append(cv.imread("equip/chests/chest_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/chests/chest_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.95) - mask.append(cv.imread("equip/chests/chest_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/chests/chest_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/chests/chest_3_32-mask.png", cv.IMREAD_COLOR)) - - -def include_books(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/books/book_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/books/book_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.9) - mask.append(cv.imread("equip/books/book_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.87) - mask.append(cv.imread("equip/books/book_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/books/book_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/books/book_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.9) - mask.append(cv.imread("equip/books/book_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/books/book_7_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_8_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/books/book_8_32-mask.png", cv.IMREAD_COLOR)) - - -def include_keys(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/keys/key_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/keys/key_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/keys/key_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/keys/key_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/keys/key_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/keys/key_3_32-mask.png", cv.IMREAD_COLOR)) - - -def include_pots(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/pots/pot_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.94) - mask.append(cv.imread("equip/pots/pot_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_6_32-mask.png", cv.IMREAD_COLOR)) - - -def include_bags(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/bags/bag_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.88) - mask.append(cv.imread("equip/bags/bag_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_coins(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/coins/coin_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/coins/coin_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/coins/coin_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/coins/coin_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/coins/coin_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_5_32-mask.png", cv.IMREAD_COLOR)) - - -def include_runes(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/runes/rune_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/runes/rune_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/runes/rune_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/runes/rune_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/runes/rune_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/runes/rune_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/runes/rune_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/runes/rune_4_32-mask.png", cv.IMREAD_COLOR)) - -def include_mushs(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/mushrooms/mush_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_amus(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/amus/amu_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.9) - mask.append(cv.imread("equip/amus/amu_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.9) - mask.append(cv.imread("equip/amus/amu_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_swords(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/swords/sword_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_7_32-mask.png", cv.IMREAD_COLOR)) - -def include_staffs(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/staffs/staff_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_rings(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/rings/ring_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.925) - mask.append(cv.imread("equip/rings/ring_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.94) - mask.append(cv.imread("equip/rings/ring_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/rings/ring_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/rings/ring_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/rings/ring_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/rings/ring_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/rings/ring_7_32-mask.png", cv.IMREAD_COLOR)) - -def include_wands(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/wands/wand_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_7_32-mask.png", cv.IMREAD_COLOR)) - -if __name__ == "__main__": - run() diff --git a/equipment_main_ui.py b/equipment_main_ui.py deleted file mode 100644 index 0a23876..0000000 --- a/equipment_main_ui.py +++ /dev/null @@ -1,795 +0,0 @@ -import random -from operator import itemgetter -from time import time - -import equipment_overlay -from window_capture import WindowCapture -from vision import Vision -import cv2 as cv -from hsvfilter import HsvFilter -from config_file import UserConfigs -import pydirectinput -import keyboard -from utils import dig_point -from equipment_overlay import EquipmentOverlay - -EMITTER_MAIN = "main" -EMITTER_MUSH = "mushroom" -EMITTER_AMU = "amulett" -EMITTER_SWORD = "sword" -EMITTER_STAFF = "staff" -EMITTER_WAND = "wand" -EMITTER_RING = "ring" -EMITTER_MULTI = "multi" - -HSV_DEFAULT = HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0) - - -def run(): - config = UserConfigs() - overlay = EquipmentOverlay(config) - - while True: - if overlay.run_mode == 'stopped': - overlay.update_status_label("stopped", "0") - overlay.run_mode = 'init' - continue - elif overlay.run_mode == 'started': - 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", "0") - overlay.run_mode = 'init' - continue - else: - break - - EMITTER_TO_USE = str(overlay.emitter_use.get()) - SPAWN_COUNT = int(overlay.spawn_use.get()) - ENERGY_TO_USE = int(overlay.energy_use.get()) - - # initialize the StunWindowCapture class - try: - capture_window = WindowCapture( - None, "equip", config) - except: - # StunWindowCapture.list_window_names() - print("Game not running, exiting") - # capture_window = cv.VideoCapture("snip_slam.mp4") - return - - # initialize the StunVision class - vision_stun = Vision() - - outer_loop_time = time() - - needles = [] - hsvs = [] - tresholds = [] - masks = [] - emitters = [] - - if EMITTER_TO_USE == EMITTER_MULTI: - emitters.append(EMITTER_RING) - emitters.append(EMITTER_WAND) - emitters.append(EMITTER_SWORD) - emitters.append(EMITTER_AMU) - emitters.append(EMITTER_STAFF) - else: - emitters.append(EMITTER_TO_USE) - - energy_counter = 0 - - for emitter in emitters: - if overlay.run_mode == 'stopped': - break - if emitter == EMITTER_MUSH: - include_books(needles, hsvs, tresholds, masks) - include_mushs(needles, hsvs, tresholds, masks) - include_pots(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_AMU: - include_books(needles, hsvs, tresholds, masks) - include_amus(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_MAIN: - include_books(needles, hsvs, tresholds, masks) - include_chests(needles, hsvs, tresholds, masks) - include_keys(needles, hsvs, tresholds, masks) - include_pots(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - include_coins(needles, hsvs, tresholds, masks) - include_runes(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_SWORD: - include_books(needles, hsvs, tresholds, masks) - include_swords(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_STAFF: - include_books(needles, hsvs, tresholds, masks) - include_staffs(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_RING: - include_books(needles, hsvs, tresholds, masks) - include_rings(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - elif emitter == EMITTER_WAND: - include_books(needles, hsvs, tresholds, masks) - include_wands(needles, hsvs, tresholds, masks) - include_bags(needles, hsvs, tresholds, masks) - - c_needle = cv.imread("equip/chests/chest_4_32.jpg", cv.IMREAD_UNCHANGED) - c_mask = cv.imread("equip/chests/chest_4_32-mask.png", cv.IMREAD_COLOR) - k_needle = cv.imread("equip/keys/key_4_32.jpg", cv.IMREAD_UNCHANGED) - k_mask = cv.imread("equip/keys/key_4_32-mask.png", cv.IMREAD_COLOR) - dig_button = cv.imread("dig/ok_button.jpg", cv.IMREAD_UNCHANGED) - loop_time_p = time() - - while True: - if overlay.run_mode == 'paused': - cv.waitKey(1) - if (time() - loop_time_p) >= 5: - loop_time_p = time() - print("pausing") - continue - elif overlay.run_mode == 'stopped': - break - - try: - # get an updated image of the game - screenshot = capture_window.get_screenshot() - # screenshot = cv.imread("buffbar.jpg") - except: - capture_window.release() - print("Game window not available - shutting down application") - break - # cv.imshow("screenshot", screenshot) - # cv.waitKey(150) - # continue - if energy_counter >= ENERGY_TO_USE: - energy_counter = 0 - break - - spawn_1 = find_emitter(emitter, vision_stun, screenshot, 1) - if len(spawn_1) == 1: - spawn_button_active = True - points = vision_stun.get_click_points(spawn_1) - for i in range(0, SPAWN_COUNT, 1): - click_point(config, points[0][0], points[0][1]) - energy_counter = energy_counter + 1 - overlay.update_status_label(emitter, ENERGY_TO_USE - energy_counter) - if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused': - break - else: - spawn_0 = find_emitter(emitter, vision_stun, screenshot, 0) - points = vision_stun.get_click_points(spawn_0) - for point in points: - click_point(config, points[0][0], points[0][1]) - - if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused': - break - continue - - cv.waitKey(500) - - if emitter == EMITTER_MAIN: - while True: - screenshot = capture_window.get_screenshot() - c_rectangles = vision_stun.find(screenshot, c_needle, 0.95, 1, True, c_mask) - k_rectangles = vision_stun.find(screenshot, k_needle, 0.95, 1, True, k_mask) - if (len(c_rectangles) == 1) and (len(k_rectangles) == 1): - c_point = vision_stun.get_click_points(c_rectangles)[0] - k_point = vision_stun.get_click_points(k_rectangles)[0] - move_tile(config, k_point, c_point) - else: - break - - for rer in range(0, len(needles), 1): - loop_time = time() - while True: - if (time() - loop_time) >= 60: - break - screenshot = capture_window.get_screenshot_by_area(config.returnOKWindowPos()) - rectangles = vision_stun.find(screenshot, dig_button, 0.5, 1) - if len(rectangles) == 1: - pointis = vision_stun.get_click_points(rectangles) - for pointi in pointis: - dig_point(pointi[0] + config.returnOKWindowPos()[2], - pointi[1] + config.returnOKWindowPos()[3], 150) - cv.waitKey(60000) - continue - # do object detection - screenshot = capture_window.get_screenshot() - # processed_screenshot = vision_stun.apply_hsv_filter(screenshot, hsvs[rer]) - # processed_needle = vision_stun.apply_hsv_filter(needles[rer], hsvs[rer]) - - rectangles = vision_stun.find_by_mask_and_validate(screenshot, needles[rer], masks[rer], 5) - # draw the detection results onto the original image - # output_image = vision_stun.draw_rectangles(screenshot, rectangles) - # cv.imshow("output_image", output_image) - # cv.waitKey(150) - - if len(rectangles) is not 5: - break - if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused': - break - - # sort rectangles by top - rectangles = sorted(rectangles, key=itemgetter(1)) - - points = vision_stun.get_click_points(rectangles) - - move_breaker = check_and_move_tile(capture_window, vision_stun, config, - [70, 70, rectangles[0][0] + 70, rectangles[0][1]], - needles[rer], - hsvs[rer], tresholds[rer], masks[rer], - points[1], [points[0][0] + 70, points[0][1]]) - if move_breaker: - break - if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused': - break - move_breaker = check_and_move_tile(capture_window, vision_stun, config, - [70, 70, rectangles[0][0], rectangles[0][1] + 70], - needles[rer], - hsvs[rer], tresholds[rer], masks[rer], - points[2], [points[0][0], points[0][1] + 70]) - if move_breaker: - break - if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused': - break - move_breaker = check_and_move_tile(capture_window, vision_stun, config, - [70, 70, rectangles[0][0] + 70, rectangles[0][1] + 70], - needles[rer], hsvs[rer], tresholds[rer], masks[rer], - points[3], [points[0][0] + 70, points[0][1] + 70]) - if move_breaker: - break - move_tile(config, points[4], [points[0][0], points[0][1]]) - if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused': - break - if overlay.run_mode == 'stopped' or overlay.run_mode == 'paused': - break - # debug the loop rate - print('FPS {}'.format(1 / (time() - outer_loop_time))) - outer_loop_time = time() - cv.waitKey(150) - overlay.run_mode = 'finished' - - - -def check_and_move_tile(capture_win, visio, conf, rect, needl, hsv, tresh, mask, point_source, point_dest): - screenshot_p = capture_win.get_screenshot() - screenshot_p_w = screenshot_p.shape[1] - screenshot_p_h = screenshot_p.shape[0] - w = rect[0] - h = rect[1] - x = rect[2] - y = rect[3] - if h >= screenshot_p_h or w >= screenshot_p_w: - return True - - screenshot_pos = screenshot_p[y:y + h, x:x + w] # (w, h, x+w, y+h) - # processed_screenshot = visio.apply_hsv_filter(screenshot_pos, hsv) - # processed_needle = visio.apply_hsv_filter(needl, hsv) - result2 = cv.matchTemplate(screenshot_pos, needl, cv.TM_CCOEFF_NORMED) - _minVal2, _maxVal2, minLoc2, maxLoc2 = cv.minMaxLoc(result2, None) - # rectangles2 = visio.find(screenshot_pos, needl, tresh, 1, True, mask) - # output_by_area = vision_stun.draw_rectangles(screenshot_pos2, rectangles) - # cv.imshow("output_image_by_area", screenshot_pos) - # cv.waitKey(150) - # print("thresh in movecheck:" + str(_maxVal2)) - if _maxVal2 <= 0.9: - move_tile(conf, point_source, point_dest) - - return False - - -def click_point(conf, x, y): - offset_left = conf.returnEquipmentWindowPos()[2] - offset_down = conf.returnEquipmentWindowPos()[3] - pydirectinput.moveTo(x + offset_left, y + offset_down) - pydirectinput.mouseDown() - w = random.randint(1, 50) - cv.waitKey(30 + w) - pydirectinput.mouseUp() - - -def move_tile(conf, point_source, point_dest): - offset_left = conf.returnEquipmentWindowPos()[2] - offset_down = conf.returnEquipmentWindowPos()[3] - pydirectinput.moveTo(point_source[0] + offset_left, point_source[1] + offset_down) - pydirectinput.mouseDown() - w = random.randint(25, 50) - cv.waitKey(100 + w) - pydirectinput.moveTo(point_dest[0] + offset_left, point_dest[1] + offset_down) - pydirectinput.mouseUp() - cv.waitKey(400 + w) - - -def find_emitter(emitter_to_use, vis, screen, layer): - if emitter_to_use == EMITTER_MUSH: - if layer == 0: - needle = cv.imread("equip/emitters/mush_e_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/mush_e_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/mush_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/mush_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.98, 1, True, mask) - elif emitter_to_use == EMITTER_AMU: - if layer == 0: - needle = cv.imread("equip/emitters/amu_e_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/amu_e_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/amu_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/amu_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - elif emitter_to_use == EMITTER_MAIN: - if layer == 0: - needle = cv.imread("equip/emitters/main_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/main_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/main_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/main_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - elif emitter_to_use == EMITTER_SWORD: - if layer == 0: - needle = cv.imread("equip/emitters/sword_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/sword_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/sword_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/sword_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.98, 1, True, mask) - elif emitter_to_use == EMITTER_STAFF: - if layer == 0: - needle = cv.imread("equip/emitters/staff_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/staff_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/staff_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/staff_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.99, 1, True, mask) - elif emitter_to_use == EMITTER_RING: - if layer == 0: - needle = cv.imread("equip/emitters/ring_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/ring_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/ring_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/ring_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - elif emitter_to_use == EMITTER_WAND: - if layer == 0: - needle = cv.imread("equip/emitters/wand_e1_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/wand_e1_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.95, 1, True, mask) - else: - needle = cv.imread("equip/emitters/wand_e2_32.jpg", cv.IMREAD_UNCHANGED) - mask = cv.imread("equip/emitters/wand_e2_32-mask.png", cv.IMREAD_COLOR) - return vis.find(screen, needle, 0.96, 1, True, mask) - - -def include_chests(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/chests/chest_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.95) - mask.append(cv.imread("equip/chests/chest_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/chests/chest_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.95) - mask.append(cv.imread("equip/chests/chest_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/chests/chest_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/chests/chest_3_32-mask.png", cv.IMREAD_COLOR)) - - -def include_books(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/books/book_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/books/book_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.9) - mask.append(cv.imread("equip/books/book_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.87) - mask.append(cv.imread("equip/books/book_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/books/book_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/books/book_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.9) - mask.append(cv.imread("equip/books/book_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/books/book_7_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/books/book_8_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/books/book_8_32-mask.png", cv.IMREAD_COLOR)) - - -def include_keys(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/keys/key_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/keys/key_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/keys/key_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/keys/key_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/keys/key_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/keys/key_3_32-mask.png", cv.IMREAD_COLOR)) - - -def include_pots(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/pots/pot_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.94) - mask.append(cv.imread("equip/pots/pot_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/pots/pot_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/pots/pot_6_32-mask.png", cv.IMREAD_COLOR)) - - -def include_bags(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/bags/bag_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.88) - mask.append(cv.imread("equip/bags/bag_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/bags/bag_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/bags/bag_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_coins(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/coins/coin_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/coins/coin_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/coins/coin_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/coins/coin_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/coins/coin_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/coins/coin_5_32-mask.png", cv.IMREAD_COLOR)) - - -def include_runes(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/runes/rune_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/runes/rune_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/runes/rune_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/runes/rune_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/runes/rune_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/runes/rune_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/runes/rune_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/runes/rune_4_32-mask.png", cv.IMREAD_COLOR)) - - -def include_mushs(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/mushrooms/mush_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/mushrooms/mush_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/mushrooms/mush_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_amus(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/amus/amu_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.9) - mask.append(cv.imread("equip/amus/amu_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.9) - mask.append(cv.imread("equip/amus/amu_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/amus/amu_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/amus/amu_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_swords(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/swords/sword_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/swords/sword_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/swords/sword_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_staffs(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/staffs/staff_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/staffs/staff_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/staffs/staff_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_rings(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/rings/ring_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.925) - mask.append(cv.imread("equip/rings/ring_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.94) - mask.append(cv.imread("equip/rings/ring_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/rings/ring_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/rings/ring_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/rings/ring_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.91) - mask.append(cv.imread("equip/rings/ring_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/rings/ring_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/rings/ring_7_32-mask.png", cv.IMREAD_COLOR)) - - -def include_wands(needles, hsv, tresh, mask): - needles.append(cv.imread("equip/wands/wand_1_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_1_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_2_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_2_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_3_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_3_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_4_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_4_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_5_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_5_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_6_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_6_32-mask.png", cv.IMREAD_COLOR)) - - needles.append(cv.imread("equip/wands/wand_7_32.jpg", cv.IMREAD_UNCHANGED)) - hsv.append(HSV_DEFAULT) - tresh.append(0.93) - mask.append(cv.imread("equip/wands/wand_7_32-mask.png", cv.IMREAD_COLOR)) - - -if __name__ == "__main__": - run() diff --git a/equipment_overlay.py b/equipment_overlay.py deleted file mode 100644 index 9a672a2..0000000 --- a/equipment_overlay.py +++ /dev/null @@ -1,121 +0,0 @@ -# Run tkinter code in another thread -import threading -import tkinter as tk -from tkinter import ttk - - -class EquipmentOverlay(threading.Thread): - - def __init__(self, config): - threading.Thread.__init__(self) - - self.run_mode = 'init' - - self.root = tk.Tk - - self.energy_use = tk.StringVar - self.spawn_use = tk.StringVar - self.emitter_use = tk.StringVar - - self.EnergyLabel = tk.Label - self.EnergyEntry = tk.Entry - self.SpawnLabel = tk.Label - self.SpawnEntry = tk.Entry - self.EmitterLabel = tk.Label - self.Emitter_Box = ttk.Combobox - - self.StartButton = tk.Button - self.StopButton = tk.Button - self.PauseButton = tk.Button - self.TkPosition = '135x115+60+600' - - self.StatusLabel = tk.Label - - # self.TkPosition = config.returnEnemyPlayerOverlayPos() - self.start() - - def run(self): - self.root = tk.Tk() - - self.energy_use = tk.StringVar(self.root, value='2000') - self.spawn_use = tk.StringVar(self.root, value='25') - self.emitter_use = tk.StringVar(self.root, value='multi') - - self.EnergyLabel = tk.Label(self.root, text="Energy:", font=("Helvetica", 10, "bold"), - background="grey") - self.EnergyLabel.grid(row=0, column=0) - self.EnergyEntry = tk.Entry(self.root, textvariable=self.energy_use, font=("Helvetica", 10, "bold"), width='12') - - self.EnergyEntry.grid(row=0, column=1, columnspan=2) - - self.SpawnLabel = tk.Label(self.root, text="Spawn:", font=("Helvetica", 10, "bold"), - background="grey") - self.SpawnLabel.grid(row=1, column=0) - self.SpawnEntry = tk.Entry(self.root, textvariable=self.spawn_use, font=("Helvetica", 10, "bold"), width='12') - - self.SpawnEntry.grid(row=1, column=1, columnspan=2) - - self.EmitterLabel = tk.Label(self.root, text="Emitter:", font=("Helvetica", 10, "bold"), - background="grey") - self.EmitterLabel.grid(row=2, column=0) - self.Emitter_Box = ttk.Combobox(self.root, textvariable=self.emitter_use, font=("Helvetica", 8, "bold"), - width='10') - self.Emitter_Box['values'] = ('multi', 'main', 'mushroom', 'amulett', 'sword', 'staff', 'wand', 'ring') - self.Emitter_Box.grid(row=2, column=1, columnspan=2, sticky='w') - - # self.EnemyLabel.pack() - self.ButtonFrame = tk.Frame(self.root) - self.StartButton = tk.Button(self.ButtonFrame, text="Start", command=self.start_button_callback, width='5') - self.StartButton.grid(row=0, column=0) - self.StopButton = tk.Button(self.ButtonFrame, text="Stop", command=self.stop_button_callback, width='5', - state=tk.DISABLED) - self.StopButton.grid(row=0, column=1) - self.PauseButton = tk.Button(self.ButtonFrame, text="Pause", command=self.pause_button_callback, width='5', - state=tk.DISABLED) - self.PauseButton.grid(row=0, column=2) - self.ButtonFrame.grid(row=3, column=0, columnspan=2) - - self.StatusLabel = tk.Label(self.root, text="", font=("Helvetica", 10, "bold"), - background="grey") - self.StatusLabel.grid(row=4, column=0, columnspan=2) - - # self.ClearButton.pack(side="top") - self.root.geometry(self.TkPosition) - self.root.overrideredirect(1) # fenster ohne aussen rum :-) - #self.root.attributes('-alpha', 0.7) # fenster transparent - self.root.attributes('-topmost', 1) # fenster immer im vordergrund - # self.root.wm_attributes("-disabled", True) - self.root.configure(background='black') - self.root.mainloop() - - def update_enemy_label(self, _text): - self.EnergyLabel.configure(text=_text) - # self.EnemyLabel.pack() - - def start_button_callback(self): - self.StartButton.configure(state=tk.DISABLED) - self.StopButton.configure(state=tk.NORMAL) - self.PauseButton.configure(state=tk.NORMAL) - self.StatusLabel.configure(text='') - self.run_mode = 'started' - - # self.EnemyLabel.pack() - - def stop_button_callback(self): - self.StartButton.configure(state=tk.NORMAL) - self.StopButton.configure(state=tk.DISABLED) - self.PauseButton.configure(state=tk.DISABLED) - self.run_mode = 'stopped' - - def pause_button_callback(self): - self.StartButton.configure(state=tk.NORMAL) - self.StopButton.configure(state=tk.NORMAL) - self.PauseButton.configure(state=tk.DISABLED) - self.run_mode = 'paused' - - def get_run_mode(self): - return self.run_mode - - def update_status_label(self, emitter, energy_to_go): - text = emitter + ": " + str(energy_to_go) - self.StatusLabel.configure(text=text) \ No newline at end of file diff --git a/farm/Field_Representation.py b/farm.py similarity index 82% rename from farm/Field_Representation.py rename to farm.py index 9906942..4af7522 100644 --- a/farm/Field_Representation.py +++ b/farm.py @@ -30,11 +30,15 @@ CIBUTRANT = 24 ARTISENT = 25 -class Field: +class Farm: data_value_grid = [] data_coordinates = [] - next_level = cv.imread("next_level.jpg", cv.IMREAD_COLOR) - next_level_x = cv.imread("next_level_x.jpg", cv.IMREAD_COLOR) + next_level = cv.imread("farm/next_level.jpg", cv.IMREAD_COLOR) + next_level_x = cv.imread("farm/next_level_x.jpg", cv.IMREAD_COLOR) + reset_board = cv.imread("farm/reset_button.jpg", cv.IMREAD_COLOR) + reset_confirm = cv.imread("farm/reset_confirm.jpg", cv.IMREAD_COLOR) + reset_counter = 0 + explosives = [] explosives.append(RAINBOW) explosives.append(ARROW_RIGHT) @@ -54,7 +58,8 @@ class Field: colors.append(ARTISENT) - def __init__(self): + def __init__(self, overlay): + self.overlay = overlay self.data_value_grid = np.zeros((8, 14), dtype=int) self.data_coordinates = np.zeros((8, 14), dtype=object) self.observation = np.zeros((8, 14), dtype=int) @@ -74,29 +79,39 @@ class Field: # initialize the StunVision class self.vision_stun = Vision() - self.needles = {GREEN: cv.imread("green.jpg", cv.IMREAD_COLOR), - YELLOW: cv.imread("yellow.jpg", cv.IMREAD_COLOR), - BLUE: cv.imread("blue.jpg", cv.IMREAD_COLOR), - RED: cv.imread("red.jpg", cv.IMREAD_COLOR), - PINK: cv.imread("pink.jpg", cv.IMREAD_COLOR), - RAINBOW: cv.imread("rainbow.jpg", cv.IMREAD_COLOR), - BIGBOMB: cv.imread("bigbomb.jpg", cv.IMREAD_COLOR), - BOMB: cv.imread("bomb.jpg", cv.IMREAD_COLOR), - ARROW_DOWN: cv.imread("arrow_down.jpg", cv.IMREAD_COLOR), - ARROW_RIGHT: cv.imread("arrow_right.jpg", cv.IMREAD_COLOR), - ROCK_1: cv.imread("rock1.jpg", cv.IMREAD_COLOR), - ROCK_2: cv.imread("rock2.jpg", cv.IMREAD_COLOR), - ROCK_3: cv.imread("rock3.jpg", cv.IMREAD_COLOR), - BURGER: cv.imread("burger.jpg", cv.IMREAD_COLOR), - GOLDBAR: cv.imread("burger.jpg", cv.IMREAD_COLOR), - PAB1: cv.imread("pab1.jpg", cv.IMREAD_COLOR), - MAGINENT: cv.imread("maginent.jpg", cv.IMREAD_COLOR), - CHEMTRANT: cv.imread("chemtrant.jpg", cv.IMREAD_COLOR), - TENESENT: cv.imread("tenesent.jpg", cv.IMREAD_COLOR), - CIBUTRANT: cv.imread("cibutrant.jpg", cv.IMREAD_COLOR), - ARTISENT: cv.imread("artisent.jpg", cv.IMREAD_COLOR) + self.needles = {GREEN: cv.imread("farm/green.jpg", cv.IMREAD_COLOR), + YELLOW: cv.imread("farm/yellow.jpg", cv.IMREAD_COLOR), + BLUE: cv.imread("farm/blue.jpg", cv.IMREAD_COLOR), + RED: cv.imread("farm/red.jpg", cv.IMREAD_COLOR), + PINK: cv.imread("farm/pink.jpg", cv.IMREAD_COLOR), + RAINBOW: cv.imread("farm/rainbow.jpg", cv.IMREAD_COLOR), + BIGBOMB: cv.imread("farm/bigbomb.jpg", cv.IMREAD_COLOR), + BOMB: cv.imread("farm/bomb.jpg", cv.IMREAD_COLOR), + ARROW_DOWN: cv.imread("farm/arrow_down.jpg", cv.IMREAD_COLOR), + ARROW_RIGHT: cv.imread("farm/arrow_right.jpg", cv.IMREAD_COLOR), + ROCK_1: cv.imread("farm/rock1.jpg", cv.IMREAD_COLOR), + ROCK_2: cv.imread("farm/rock2.jpg", cv.IMREAD_COLOR), + ROCK_3: cv.imread("farm/rock3.jpg", cv.IMREAD_COLOR), + BURGER: cv.imread("farm/burger.jpg", cv.IMREAD_COLOR), + GOLDBAR: cv.imread("farm/burger.jpg", cv.IMREAD_COLOR), + PAB1: cv.imread("farm/pab1.jpg", cv.IMREAD_COLOR), + MAGINENT: cv.imread("farm/maginent.jpg", cv.IMREAD_COLOR), + CHEMTRANT: cv.imread("farm/chemtrant.jpg", cv.IMREAD_COLOR), + TENESENT: cv.imread("farm/tenesent.jpg", cv.IMREAD_COLOR), + CIBUTRANT: cv.imread("farm/cibutrant.jpg", cv.IMREAD_COLOR), + ARTISENT: cv.imread("farm/artisent.jpg", cv.IMREAD_COLOR) } + def execute_main_loop(self): + while True: + if self.overlay.run_mode == 'paused': + cv.waitKey(1) + continue + elif self.overlay.run_mode == 'stopped': + break + + self.assess_playfield_and_make_move() + def reset(self): self.observation = [] @@ -108,13 +123,41 @@ class Field: # last board state is same as actual if mse(new_observation, self.observation) == 0.0: # no movement detected -> blow explosives or reset - self.detonate_explosive_when_stuck(new_observation) - cv.waitKey(500) + + self.reset_counter += 1 + if self.reset_counter == 1: + pass + elif self.reset_counter == 2: + if self.detonate_explosive_when_stuck(new_observation): + new_observation, new_screenshot = self.get_current_board_state() + if mse(new_observation, self.observation) != 0.0: + self.reset_counter = 0 + return + elif self.reset_counter >= 3: + screenshot = self.capture_window.get_screenshot() + if self.check_for_button_and_execute(screenshot, self.reset_board): + cv.waitKey(500) + screenshot = self.capture_window.get_screenshot() + if self.check_for_button_and_execute(screenshot, self.reset_confirm): + cv.waitKey(500) + + self.reset_counter = 0 + return + else: + return self.find_patterns_and_valid_moves(new_observation) self.observation = new_observation return new_observation + def check_for_button_and_execute(self, screen, needle, offset_left=0, offset_down=0): + rectangles = self.vision_stun.find(screen, needle, 0.70, 1) + if len(rectangles) == 0: + return False + point = self.vision_stun.get_click_points(rectangles)[0] + self.dig_point(point[0] + offset_left, point[1] + offset_down, 500) + return True + def move_to(self, x, y): point_src = (1113, 598) pydirectinput.moveTo(point_src[0], point_src[1]) @@ -200,6 +243,10 @@ class Field: for i in range(0, 14, 1): if self.check_explosives(state, e, i): return + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break for e in range(0, 8, 1): for i in range(0, 14, 1): @@ -208,6 +255,12 @@ class Field: return if self.check_5_vertical(state, e, i, color): return + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break for e in range(0, 8, 1): for i in range(0, 14, 1): @@ -218,6 +271,12 @@ class Field: return if self.check_3_with_gap(state, e, i, color): return + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break def detonate_explosive_when_stuck(self, state): for e in range(0, 8, 1): @@ -228,18 +287,22 @@ class Field: if self.local_pos_checks(state, e, i, 1, 0, self.colors): src_pt = self.get_click_point(self.data_coordinates[e + 1, i]) self.move_tile(src_pt, dest_pt) + return True elif self.local_pos_checks(state, e, i, 0, 1, self.colors): src_pt = self.get_click_point(self.data_coordinates[e, i + 1]) self.move_tile(src_pt, dest_pt) + return True elif self.local_pos_checks(state, e, i, -1, 0, self.colors): src_pt = self.get_click_point(self.data_coordinates[e - 1, i]) self.move_tile(src_pt, dest_pt) + return True elif self.local_pos_checks(state, e, i, 0, -1, self.colors): src_pt = self.get_click_point(self.data_coordinates[e, i - 1]) self.move_tile(src_pt, dest_pt) + return True else: continue - return + return False def check_explosives(self, state, e, i): for explosive in self.explosives: diff --git a/farm/farm_overlay.py b/farm/farm_overlay.py deleted file mode 100644 index ebc753d..0000000 --- a/farm/farm_overlay.py +++ /dev/null @@ -1,66 +0,0 @@ -# Run tkinter code in another thread -import threading -import tkinter as tk -from tkinter import ttk - - -class FarmOverlay(threading.Thread): - - def __init__(self): - threading.Thread.__init__(self) - - self.run_mode = 'init' - - self.root = tk.Tk - - self.ButtonFrame = tk.Frame - - self.StartButton = tk.Button - self.StopButton = tk.Button - self.TkPosition = '133x52+60+600' - - self.StatusLabel = tk.Label - - self.start() - - def run(self): - self.root = tk.Tk() - self.ButtonFrame = tk.Frame(self.root) - self.StartButton = tk.Button(self.ButtonFrame, text="Start", command=self.start_button_callback, width='8') - self.StartButton.grid(row=0, column=0) - self.StopButton = tk.Button(self.ButtonFrame, text="Stop", command=self.stop_button_callback, width='8', - state=tk.DISABLED) - self.StopButton.grid(row=0, column=1) - - self.ButtonFrame.grid(row=3, column=0, columnspan=2) - - self.StatusLabel = tk.Label(self.root, text="", font=("Helvetica", 10, "bold"), - background="grey") - self.StatusLabel.grid(row=4, column=0, columnspan=2) - - # self.ClearButton.pack(side="top") - self.root.geometry(self.TkPosition) - self.root.overrideredirect(1) # fenster ohne aussen rum :-) - # self.root.attributes('-alpha', 0.7) # fenster transparent - self.root.attributes('-topmost', 1) # fenster immer im vordergrund - # self.root.wm_attributes("-disabled", True) - self.root.configure(background='black') - self.root.mainloop() - - def start_button_callback(self): - self.StartButton.configure(state=tk.DISABLED) - self.StopButton.configure(state=tk.NORMAL) - self.StatusLabel.configure(text='') - self.run_mode = 'started' - - def stop_button_callback(self): - self.StartButton.configure(state=tk.NORMAL) - self.StopButton.configure(state=tk.DISABLED) - self.run_mode = 'stopped' - - def get_run_mode(self): - return self.run_mode - - def update_status_label(self, mode, energy_to_go): - text = mode + ": " + str(energy_to_go) - self.StatusLabel.configure(text=text) diff --git a/farm/main_farm.py b/farm/main_farm.py deleted file mode 100644 index 1f25a98..0000000 --- a/farm/main_farm.py +++ /dev/null @@ -1,39 +0,0 @@ -from Field_Representation import Field -from time import time -import cv2 as cv -import keyboard - -def run(): - field = Field() - loop_time_p = time() - pause = True - - while True: - if keyboard.is_pressed('p') == True: - pause = True - print('q pressed') - elif keyboard.is_pressed('o') == True: - pause = False - print('o pressed') - - if pause: - # cv.waitKey(500) - if (time() - loop_time_p) >= 5: - loop_time_p = time() - print("pausing") - continue - - - #cords, screenshot = field.get_current_board_state() - cords = field.assess_playfield_and_make_move() - print(cords) - cv.waitKey(1000) - - - #cv.imshow("screenshot", screenshot) - #cv.waitKey(150) - #print(cords) - - -if __name__ == "__main__": - run() \ No newline at end of file diff --git a/farm/main_farm_ui.py b/farm/main_farm_ui.py deleted file mode 100644 index 2be0056..0000000 --- a/farm/main_farm_ui.py +++ /dev/null @@ -1,36 +0,0 @@ -from Field_Representation import Field -from time import time -import cv2 as cv -import keyboard -from farm_overlay import FarmOverlay - - -def run(): - field = Field() - overlay = FarmOverlay() - - while True: - if overlay.run_mode == 'stopped': - overlay.update_status_label("stopped", "0") - overlay.run_mode = 'init' - continue - elif overlay.run_mode == 'started': - cv.waitKey(1000) - elif overlay.run_mode == 'init': - cv.waitKey(1) - continue - else: - # boelk - pass - - while True: - if overlay.run_mode == 'stopped': - break - - cords = field.assess_playfield_and_make_move() - print(cords) - cv.waitKey(1000) - - -if __name__ == "__main__": - run() diff --git a/farm/reset_button.jpg b/farm/reset_button.jpg new file mode 100644 index 0000000..99e09da Binary files /dev/null and b/farm/reset_button.jpg differ diff --git a/farm/reset_confirm.jpg b/farm/reset_confirm.jpg new file mode 100644 index 0000000..54e7c2b Binary files /dev/null and b/farm/reset_confirm.jpg differ diff --git a/magic.py b/magic.py new file mode 100644 index 0000000..6754207 --- /dev/null +++ b/magic.py @@ -0,0 +1,155 @@ +import random +from window_capture import WindowCapture +from vision import Vision +import cv2 as cv +from hsvfilter import HsvFilter +from config_file import UserConfigs +import pydirectinput + + +class Magic: + + def __init__(self, overlay): + self.overlay = overlay + self.config = UserConfigs() + + self.SPAWN_COUNT = int(overlay.spawn_use.get()) + + self.capture_window = WindowCapture(None, "magic", self.config) + + # initialize the StunVision class + self.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) + self.hsv_filter_w = HsvFilter(69, 25, 0, 94, 255, 255, 0, 0, 0, 0) + + self.magic_list = {"1": "body", "2": "finding", "3": "mind", "4": "perceiving", "5": "physical", "6": "seeing", + "7": "spiritual"} + self.tier_list = {"1": "0", "2": "orange", "3": "y", "4": "g", "5": "b", "6": "p"} # , "w"} + self.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} + + self.needle_list = [] + self.hsv_list = [] + for key1 in self.tier_list: + for key2 in self.magic_list: + self.needle_list.append( + cv.imread("magic/" + self.magic_list[key2] + "_" + self.tier_list[key1] + ".jpg", + cv.IMREAD_UNCHANGED)) + self.hsv_list.append(self.hsv_filter_list[key1]) + + def execute_main_loop(self): + + while True: + if self.overlay.run_mode == 'paused': + cv.waitKey(1) + continue + elif self.overlay.run_mode == 'stopped': + break + + screenshot = self.capture_window.get_screenshot() + # screenshot = cv.imread("buffbar.jpg") + + # cv.imshow("screenshot", screenshot) + # cv.waitKey(150) + # continue + + spawn_1 = self.vision_stun.find(screenshot, cv.imread("magic/spawn_1.jpg", cv.IMREAD_UNCHANGED), 0.4, 1) + if len(spawn_1) == 1: + points = self.vision_stun.get_click_points(spawn_1) + for i in range(0, self.SPAWN_COUNT, 1): + pydirectinput.moveTo(points[0][0], points[0][1]) + pydirectinput.mouseDown() + w = random.randint(1, 50) + cv.waitKey(30 + w) + pydirectinput.mouseUp() + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + else: + spawn_0 = self.vision_stun.find(screenshot, cv.imread("magic/spawn_0.jpg", cv.IMREAD_UNCHANGED), 0.7, 1) + points = self.vision_stun.get_click_points(spawn_0) + for point in points: + pydirectinput.moveTo(point[0], point[1]) + pydirectinput.mouseDown() + cv.waitKey(500) + pydirectinput.mouseUp() + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + continue + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + # for needles in needle_list: + for rer in range(0, len(self.needle_list), 1): + while True: + screenshot = self.capture_window.get_screenshot() + processed_screenshot = self.vision_stun.apply_hsv_filter(screenshot, self.hsv_list[rer]) + processed_needle = self.vision_stun.apply_hsv_filter(self.needle_list[rer], self.hsv_list[rer]) + + rectangles = self.vision_stun.find(processed_screenshot, processed_needle, 0.7, 2) + # draw the detection results onto the original image + + # only trigger ocr reading if a stun is detected + points = self.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 self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + else: + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + + needles_white = [cv.imread("magic/body_w.jpg", cv.IMREAD_UNCHANGED), + cv.imread("magic/finding_w.jpg", cv.IMREAD_UNCHANGED), + cv.imread("magic/mind_w.jpg", cv.IMREAD_UNCHANGED), + cv.imread("magic/perceiving_w.jpg", cv.IMREAD_UNCHANGED), + cv.imread("magic/physical_w.jpg", cv.IMREAD_UNCHANGED), + cv.imread("magic/seeing_w.jpg", cv.IMREAD_UNCHANGED), + cv.imread("magic/spiritual_w.jpg", cv.IMREAD_UNCHANGED)] + + for needle_w in needles_white: + # do object detection + screenshot = self.capture_window.get_screenshot() + processed_screenshot = self.vision_stun.apply_hsv_filter(screenshot, self.hsv_filter_w) + processed_needle = self.vision_stun.apply_hsv_filter(needle_w, self.hsv_filter_w) + rectangles = self.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 = self.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 = self.capture_window.get_screenshot() + rectangles = self.vision_stun.find(screenshot, cv.imread("magic/collect.jpg", cv.IMREAD_UNCHANGED), + 0.8, + 1) + points = self.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 self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break diff --git a/magic/perceiving_0.jpg b/magic/perceiving_0.jpg index a8ce413..fe5a272 100644 Binary files a/magic/perceiving_0.jpg and b/magic/perceiving_0.jpg differ diff --git a/mine.py b/mine.py new file mode 100644 index 0000000..659f809 --- /dev/null +++ b/mine.py @@ -0,0 +1,183 @@ +from config_file import UserConfigs +import cv2 as cv +from utils import dig_point, check_for_ok_button +from window_capture import WindowCapture +from vision import Vision + + +class Mine: + + def __init__(self, overlay): + self.overlay = overlay + self.config = UserConfigs() + + self.capture_window = WindowCapture(None, "screen_conf", self.config) + + # initialize the StunVision class + self.vision_stun = Vision() + + self.level = 1 + + self.width = 32 + self.depth = 24 + self.plot_size = 45 + self.DIG_TIME = 100 + + self.run_target = int(overlay.energy_use.get()) + self.run_counter = 0 + + def reset(self): + self.level = 1 + self.plot_size = 45 + self.DIG_TIME = 100 + + def execute_main_loop(self): + if self.run_target == 1: + self.execute_loop() + elif self.run_target == 2: + self.execute_loop() + if self.overlay.run_mode == 'stopped': + return + dig_point(290, 100, 200) + self.execute_loop() + + def execute_loop(self): + while True: + if self.overlay.run_mode == 'paused': + cv.waitKey(10) + self.overlay.show_mining_overlay() + continue + elif self.overlay.run_mode == 'stopped': + break + + self.overlay.hide_mining_overlay() + + if self.level >= 28: + break + if self.level == 23: + self.DIG_TIME = 800 + if self.level == 26: + self.DIG_TIME = 1800 + if self.level <= 10: + self.plot_size = self.plot_size - 1 + elif self.level % 2 == 0: + self.plot_size = self.plot_size - 1 + + p1 = int((self.config.returnDiggingWindowPos2()[0] / 2) + self.config.returnDiggingWindowPos2()[2]) + p2 = int((self.config.returnDiggingWindowPos2()[1] / 2) + self.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, self.DIG_TIME) + # cv.circle(screenshot, (p1, p2), 7, (0, 255, 0), -1) + i = 0 + for e in range(2, self.width, 2): + i = i + 1 + + tp1 = p1 - (i * self.plot_size) + tp2 = p2 + (i * self.plot_size) + for f in range(0, e, 1): + # up click + tp2 = tp2 - self.plot_size + if tp2 >= self.config.returnDiggingWindowPos2()[1] + (self.plot_size / 2): + continue + if tp2 <= self.config.returnDiggingWindowPos2()[3] + (self.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 + # -> 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, self.DIG_TIME) + # cv.circle(screenshot, (tp1, tp2), 7, (255, 0, 255), -1) + # cv.imshow("screenshot", screenshot) + # cv.waitKey(150) + check_for_ok_button(self.capture_window, self.vision_stun, self.config) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + + tp1 = p1 - (i * self.plot_size) + tp2 = p2 - (i * self.plot_size) + for g in range(0, e, 1): + # right click + tp1 = tp1 + self.plot_size + if tp2 <= self.config.returnDiggingWindowPos2()[3] + (self.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, self.DIG_TIME) + # cv.circle(screenshot, (tp1, tp2), 7, (127, 0, 255), -1) + # cv.imshow("screenshot", screenshot) + # cv.waitKey(150) + check_for_ok_button(self.capture_window, self.vision_stun, self.config) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + + tp1 = p1 + (i * self.plot_size) + tp2 = p2 - (i * self.plot_size) + for r in range(0, e, 1): + # down click + tp2 = tp2 + self.plot_size + if tp2 >= self.config.returnDiggingWindowPos2()[1] + (self.plot_size / 2): + continue + if tp2 <= self.config.returnDiggingWindowPos2()[3] + (self.plot_size / 2): + continue + dig_point(tp1, tp2, self.DIG_TIME) + # cv.circle(screenshot, (tp1, tp2), 7, (255, 0, 127), -1) + # cv.imshow("screenshot", screenshot) + # cv.waitKey(150) + check_for_ok_button(self.capture_window, self.vision_stun, self.config) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + + tp1 = p1 + (i * self.plot_size) + tp2 = p2 + (i * self.plot_size) + for u in range(0, e, 1): + # left click + tp1 = tp1 - self.plot_size + if tp2 >= self.config.returnDiggingWindowPos2()[1] + (self.plot_size / 2): + continue + dig_point(tp1, tp2, self.DIG_TIME) + # cv.circle(screenshot, (tp1, tp2), 7, (0, 0, 255), -1) + # cv.imshow("screenshot", screenshot) + # cv.waitKey(150) + check_for_ok_button(self.capture_window, self.vision_stun, self.config) + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': + break + self.level = self.level + 1 diff --git a/dig_overlay.py b/mine_overlay.py similarity index 85% rename from dig_overlay.py rename to mine_overlay.py index 6768999..a1ec91d 100644 --- a/dig_overlay.py +++ b/mine_overlay.py @@ -5,16 +5,20 @@ import tkinter as tk class DiggingOverlay(threading.Thread): - def __init__(self, config): + def __init__(self): threading.Thread.__init__(self) self.root = tk.Tk self.EnemyLabel = tk.Label - self.TkPosition = config.returnDiggingOverlayPos() + self.TkPosition = '1440x1150+570+22' + self.setDaemon(True) self.start() def callback(self): self.root.quit() + def destroy(self): + self.root.destroy() + def run(self): self.root = tk.Tk() self.root.geometry(self.TkPosition)