Thaloria/Litcraft_Python_B
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

Browse Source
This commit is contained in:
Thaloria
2022-10-16 18:07:15 +02:00
parent 4a264c3439 862ce4c837
commit e662739f57
31 changed files with 1855 additions and 3089 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
breed1.jpg
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 745 KiB

BIN
breed2.jpg
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 760 KiB

BIN
candy-c/grid.jpg
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 428 KiB

BIN
candy-c/repeat.jpg
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 9.2 KiB

BIN
candy-c/reset.jpg
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 30 KiB

202
combine_main.py
View File

@@ -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()

185
combine_main_ui.py
View File

@@ -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()

66
combine_overlay.py
View File

@@ -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)

59
combined_bot_main.py Normal file
View File

@@ -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()

235
combined_user_interface.py Normal file
View File

@@ -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()

316
craft.py Normal file
View File

@@ -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)

93
craft_table/craft_overlay.py
View File

@@ -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)

337
craft_table/main_craft.py
View File

@@ -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()

66
crop/crop_overlay.py
View File

@@ -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)

36
crop/main_crop_ui.py
View File

@@ -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()

128
crop/Field_Representation_crop.py → crops.py
View File

@@ -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

202
digging_main2.py
View File

@@ -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()

728
equipment.py Normal file
View File

@@ -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))

769
equipment_main.py
View File

@@ -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()

795
equipment_main_ui.py
View File

@@ -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()

121
equipment_overlay.py
View File

@@ -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)

119
farm/Field_Representation.py → farm.py
View File

@@ -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:

66
farm/farm_overlay.py
View File

@@ -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)

39
farm/main_farm.py
View File

@@ -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()

36
farm/main_farm_ui.py
View File

@@ -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()

BIN
farm/reset_button.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.1 KiB

BIN
farm/reset_confirm.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 13 KiB

155
magic.py Normal file
View File

@@ -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

BIN
magic/perceiving_0.jpg
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.7 KiB

After

Width:  |  Height:  |  Size: 3.1 KiB

183
mine.py Normal file
View File

@@ -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

8
dig_overlay.py → mine_overlay.py
View File

@@ -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)