def Attack():
os.chdir(os.path.dirname(os.path.abspath(__file__)))
wincap = WindowCapture('Legends of Runeterra')
#vision_IP = Vision('img\minalegal.jpg')
#haystack_img = cv.imread('img\este1.jpg', cv.IMREAD_UNCHANGED)
needle_img = cv.imread('img\mobBeSelected.jpg', cv.IMREAD_UNCHANGED)
result = cv.matchTemplate(wincap.get_screenshot(), needle_img, cv.TM_CCOEFF_NORMED)
#cv.imshow('Result', result)
#cv.waitKey()
min_val, max_val, min_loc, max_loc = cv.minMaxLoc(result)
print('Best match top left position: %s' % str(max_loc))
print('Best match confidence: %s' % max_val)
print('ScreenPosition: %s' % str(wincap.get_screen_position(max_loc)))
pos = str(wincap.get_screen_position(max_loc))
arrayPos = pos.split(', ')
PosX = arrayPos[0].replace("(", '')
PosY = arrayPos[1].replace(")", '')
print(PosX)
print(PosY)
pyautogui.moveTo(int(PosX), int(PosY), 0.1)
pyautogui.dragTo(2851, 652, 0.25)
def e():
log("Waiting for client...")
time.sleep(30)
wincap = WindowCapture('League of Legends')
while (True):
try:
screenshot = wincap.get_screenshot()
except:
break
if (locate("playButton", screenshot) != None):
log("Restarting.")
break
if (locate("honor", screenshot) != None):
log("Honoring teammate...")
click(client.honorButton)
time.sleep(1)
if (locate("dailyPlay", screenshot, 0.8) != None):
log("Choosing reward...")
click(client.dailyPlayButton)
time.sleep(1)
if (locate("okButton", screenshot, 0.8) != None):
log("Choosing reward...")
click(locate("okButton", screenshot, 0.8))
time.sleep(1)
if (locate("xButton", screenshot, 0.8) != None):
log("Exiting lobby...")
click(locate("xButton", screenshot, 0.8))
time.sleep(1)
def streamScreen(window_name):
print("Starting streaming game window")
# initialize the WindowCapture class
wincap = WindowCapture(window_name)
loop_time = time()
frames = 0
while (True):
# get an updated image of the game
screenshot = wincap.get_screenshot()
cv.imshow('Computer Vision', screenshot)
frames = frames + 1
# debug the loop rate
if frames == 200:
print('FPS {}'.format(int(200 / (time() - loop_time))))
loop_time = time()
frames = 0
# press 'q' with the output window focused to exit.
# waits 1 ms every loop to process key presses
if cv.waitKey(1) == ord('q'):
cv.destroyAllWindows()
break
print('Done.')
def SelectAlly(Ally):
os.chdir(os.path.dirname(os.path.abspath(__file__)))
wincap = WindowCapture('Legends of Runeterra')
#------------------------------#
#fogolivre = ["img\\oomcrewrookie.jpg", "img\\crimsondisciple.jpg", "img\\decimate.jpg", "img\\getexcited.jpg", "img\\imperialdemoli.jpg", "img\\legiongran.jpg", "img\\legionrear.jpg", "img\\legionsaboteur.jpg", "img\\mysticshot.jpg", "img\\oxianfervor.jpg", "img\\preciouspet.jpg", "img\\statikkshock.jpg", "img\\sformation.jpg", "img\\usedcasksalesman.jpg"]
if Ally == "Legion Rearguard":
vToFind = cv.imread('img\legionrear.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Legion Saboteur":
vToFind = cv.imread('img\legionsaboteur.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Precious Pet":
vToFind = cv.imread('img\preciouspet1.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Boomcrew Rookie":
vToFind = cv.imread('img\oomcrewrookie.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Crimson Disciple":
vToFind = cv.imread('img\crimsondisciple.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Imperial Demolitionist":
vToFind = cv.imread('img\imperialdemoli.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Legion Granadier":
vToFind = cv.imread('img\legiongran.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Mystic Shot":
vToFind = cv.imread('img\mysticshot.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Transfusion":
vToFind = cv.imread('img\sformation.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Get Excited":
vToFind = cv.imread('img\getexcited.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Noxian Fervor":
vToFind = cv.imread('img\oxianfervor.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Used Cask Salesman":
vToFind = cv.imread('img\casksalesman.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Statikk Shock":
vToFind = cv.imread('img\statikkshock.jpg', cv.IMREAD_UNCHANGED)
elif Ally == "Decimate":
vToFind = cv.imread('img\decimate.jpg', cv.IMREAD_UNCHANGED)
#------------------------------#
result = cv.matchTemplate(wincap.get_screenshot(), vToFind, cv.TM_CCOEFF_NORMED)
min_val, max_val, min_loc, max_loc = cv.minMaxLoc(result)
print('Best match top left position: %s' % str(max_loc))
print('Best match confidence: %s' % max_val)
print('ScreenPosition: %s' % str(wincap.get_screen_position(max_loc)))
pos = str(wincap.get_screen_position(max_loc))
arrayPos = pos.split(', ')
PosX = arrayPos[0].replace("(", '')
PosY = arrayPos[1].replace(")", '')
print(PosX)
print(PosY)
pyautogui.click(PosX, PosY, clicks=1, interval=1)
def c():
log("Game window found.")
wincap = WindowCapture('League of Legends (TM) Client')
while (True):
try:
screenshot = wincap.get_screenshot()
except:
break
if (locate("minimap", screenshot) != None):
log("Game started.")
break
else:
log("Waiting for game to start...")
click((computerWidth / 2, computerHeight / 2))
def b():
wincap = WindowCapture('League of Legends')
while (True):
try:
screenshot = wincap.get_screenshot()
except:
break
if (locate("grayLockInButton", screenshot) == None):
if (locate("findMatchButton", screenshot) != None):
log("Finding a match...")
click(client.findMatchButton)
if (locate("acceptButton", screenshot) != None):
log("Waiting for champ select...")
click(client.acceptButton)
if (locate("chooseChampion", screenshot) != None):
chooseChamp()
log("Waiting for game window...")
time.sleep(10)
def make_cropped_ss(
LOAD_IMAGE_=LOAD_IMAGE,
cropping_x=450,
cropping_y=970,
cropping_width=1000,
cropping_height=30,
IMAGE_DEBUG_MODE_=IMAGE_DEBUG_MODE,
):
"""
Parameters
----------
LOAD_IMAGE_ : If want to open without game then change to 1.
The default is 0.
window : Window to be captured, set to None if want to open without game.
The default is wincap.
Defaults to cropp screenshot from first to fifth(1-5) champion card name.
cropping_x : The default is 450.
cropping_y : The default is 970.
cropping_width : The default is 1000.
cropping_height : The default is 30.
Returns
-------
crop_img : Cropped screenshot.
"""
logging.debug("Function make_cropped_ss() called")
if LOAD_IMAGE_:
screenshot = cv.imread("examples/ss3.jpg", cv.IMREAD_UNCHANGED)
else:
wincap = WindowCapture("League of Legends (TM) Client")
screenshot = wincap.get_screenshot()
crop_img = screenshot[cropping_y:cropping_y + cropping_height,
cropping_x:cropping_x + cropping_width, ]
if IMAGE_DEBUG_MODE_:
cv.imshow("make_cropped_ss()", crop_img)
logging.debug("Function make_cropped_ss() end")
return crop_img, screenshot
def Block(Spot):
# -------------------- Found My Card ----------------------------- #
os.chdir(os.path.dirname(os.path.abspath(__file__)))
wincap = WindowCapture('Legends of Runeterra')
needle_img = cv.imread('img\mobBeSelected.jpg', cv.IMREAD_UNCHANGED)
result = cv.matchTemplate(wincap.get_screenshot(), needle_img, cv.TM_CCOEFF_NORMED)
min_val, max_val, min_loc, max_loc = cv.minMaxLoc(result)
pos = str(wincap.get_screen_position(max_loc))
arrayPos = pos.split(', ')
PosX = arrayPos[0].replace("(", '')
PosY = arrayPos[1].replace(")", '')
pyautogui.moveTo(int(PosX), int(PosY), 0.1)
sleep(1)
spot = ["2379", "711", "2576", "713", "2751", "710", "3008", "711", "3180", "712", "3370", "706"]
if Spot == "1":
cardToBlockX = spot[0]
cardToBlockY = spot[1]
pyautogui.dragTo(int(cardToBlockX), int(cardToBlockY), 0.25)
if Spot == "2":
cardToBlockX = spot[2]
cardToBlockY = spot[3]
pyautogui.dragTo(int(cardToBlockX), int(cardToBlockY), 0.25)
if Spot == "3":
cardToBlockX = spot[4]
cardToBlockY = spot[5]
pyautogui.dragTo(int(cardToBlockX), int(cardToBlockY), 0.25)
if Spot == "4":
cardToBlockX = spot[6]
cardToBlockY = spot[7]
pyautogui.dragTo(int(cardToBlockX), int(cardToBlockY), 0.25)
if Spot == "5":
cardToBlockX = spot[8]
cardToBlockY = spot[9]
pyautogui.dragTo(int(cardToBlockX), int(cardToBlockY), 0.25)
if Spot == "6":
cardToBlockX = spot[10]
cardToBlockY = spot[11]
pyautogui.dragTo(int(cardToBlockX), int(cardToBlockY), 0.25)
# -------------------- Found My Enemy ----------------------------- #
'''wincap2 = WindowCaptureEnemy('Legends of Runeterra')
def IsMyRound():
os.chdir(os.path.dirname(os.path.abspath(__file__)))
# initialize the WindowCapture class
wincap = WindowCapture('Legends of Runeterra')
# finding myRound.jpg
#vision_IP = Vision('img\minalegal.jpg')
vToFind = Vision('img\isMyRound.jpg')
loop_time = time()
while(True):
screen = wincap.get_screenshot()
points = vToFind.find(screen, 0.99, 'rectangles')
#print('FPS {}'.format(1 / (time() - loop_time)))
if points:
print('Is my turn.')
else:
print('Not my turn')
pass
loop_time = time()
#return False
if cv.waitKey(1) == ord('q'):
cv.destroyAllWindows()
break
pass
# initialize the Vision class
vision_pilar1 = Vision('pilar1.png')
vision_pilar2 = Vision('pilar2.png')
vision_pilar3 = Vision('pilar3.png')
#vision_pilar4 = Vision('pilar4.png')
vision_pilar5 = Vision('pilar5.png')
vision_pilar6 = Vision('pilar6.png')
vision_pilar7 = Vision('pilar7.png')
#vision_pilar62 = Vision('pilar62.png')
vision_pilarPr = Vision('pilarpr.png')
loop_time = time()
while (True):
# get an updated image of the game
screenshot = wincap.get_screenshot()
points_1 = []
points_2 = []
points_3 = []
#points_4 = []
points_5 = []
points_6 = []
points_7 = []
#points_62 = []
points_pr = []
# display the processed image
points_1 = vision_pilar1.find(screenshot, 0.45, 'rectangles')
points_2 = vision_pilar2.find(screenshot, 0.6, 'rectangles')
points_3 = vision_pilar3.find(screenshot, 0.6, 'rectangles')
#points_4 = vision_pilar4.find(screenshot, 0.5)
points_5 = vision_pilar5.find(screenshot, 0.6, 'rectangles')
def d():
rightClick((computerWidth / 2, computerHeight / 2))
time.sleep(1)
q = False
w = False
e = False
buyItems()
time.sleep(1)
log("Locking screen...")
pressKey(keyboardButton.n0)
wincap = WindowCapture('League of Legends (TM) Client')
while (True):
try:
screenshot = wincap.get_screenshot()
except:
break
if (getPixel(game.recallButton) != (64, 85, 95)):
#checking health
if (getPixel(game.healthBar) == (1, 13, 7)):
rightClick(game.base)
rightClick(game.base)
pressKey(keyboardButton.D)
pressKey(keyboardButton.F)
#pressKey(keyboardButton.n1)
flag = True
for i in range(8):
flag = getPixel(game.healthBar) == (1, 13, 7)
rightClick(game.base)
time.sleep(1)
if (flag == False):
break
if flag:
pressKey(keyboardButton.B)
flag2 = True
for i in range(9):
flag2 = getPixel(game.healthBar) == (1, 13, 7)
time.sleep(1)
if (flag2 == False):
break
if flag2:
buyItems()
pressKey(keyboardButton.n4)
else:
max_loc = locateGame("casterMinion", screenshot,
np.array([111, 167, 81]),
np.array([121, 215, 130]), 0.5)
if (max_loc != None):
setPos(max_loc)
pressKey(keyboardButton.Space)
#finding champ
maxChamp_loc = locateGame("champHealth", screenshot,
np.array([2, 204, 165]),
np.array([4, 204, 166]), 0.5)
#checking tower range
max_loc = locateGame("tower", screenshot,
np.array([49, 0, 135]),
np.array([100, 40, 166]), 0.5)
#checking if theres a enemy champion
if (maxChamp_loc != None):
#checking if you are not in tower range
if (max_loc == None):
pressKey(keyboardButton.T)
maxChamp_loc = (maxChamp_loc[0] + 50,
maxChamp_loc[1] + 75)
setPos(maxChamp_loc)
pressKey(keyboardButton.E)
pressKey(keyboardButton.R)
pressKey(keyboardButton.Q)
pressKey(keyboardButton.W)
pressKey(keyboardButton.Space)
pressKey(keyboardButton.T)
time.sleep(0.5)
else:
pressKey(keyboardButton.W)
else:
x = random.randint(-25, 25)
rightClick((game.tower[0] + x, game.tower[1] - x))
#levelling up
if (locate("levelUpButton", screenshot) != None):
holdKey(keyboardButton.Lctrl)
time.sleep(0.05)
pressKey(keyboardButton.R)
if (q == False):
pressKey(keyboardButton.Q)
q = True
elif (w == False):
pressKey(keyboardButton.W)
w = True
elif (e == False):
pressKey(keyboardButton.E)
e = True
pressKey(keyboardButton.Q)
pressKey(keyboardButton.W)
pressKey(keyboardButton.E)
releaseKey(keyboardButton.Lctrl)
else:
buyItems()
log("Game has ended.")
os.chdir(os.path.dirname(os.path.abspath(__file__)))
# Inicializa o WindowCapture
wincap = WindowCapture('Camera')
# Carrega o modelo treinado
cascade_limestone = cv.CascadeClassifier('result.xml')
# Carregue uma classe Vision
vision_limestone = Vision(None)
loop_time = time()
while (True):
# get an updated image of the game
imagem = wincap.get_screenshot()
# Detecção de objetos
rectangles = cascade_limestone.detectMultiScale(imagem)
# Desenha os resultados da detecção na imagem original
detection_image = vision_limestone.draw_rectangles(imagem, rectangles)
# Exibe a imagem
cv.imshow('Imagem', detection_image)
loop_time = time()
key = cv.waitKey(1)
# presionar Q para fecahr
if key == ord('q'):
windows = Desktop(backend="uia").windows()
for i in windows:
if i.window_text().startswith("GS"):
windowname = i.window_text()
print("Found Emulator")
wincap = WindowCapture(windowname)
loop_time = time()
with detection_graph.as_default():
with tf.Session(graph=detection_graph,
config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
while True:
# for image_path in TEST_IMAGE_PATHS:
# image = Image.open(image_path)
image_np = wincap.get_screenshot()
# result image with boxes and labels on it.
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = np.expand_dims(image_np, axis=0)
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Each box represents a part of the image where a particular object was detected.
boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Each score represent how level of confidence for each of the objects.
# Score is shown on the result image, together with the class label.
scores = detection_graph.get_tensor_by_name('detection_scores:0')
classes = detection_graph.get_tensor_by_name('detection_classes:0')
num_detections = detection_graph.get_tensor_by_name(
'num_detections:0')
# Actual detection.
(boxes, scores, classes, num_detections) = sess.run(
class Movement:
# Properties
wincap = None
vision_target = None
firstRun = True
points = []
current = ''
key = None
user = b'gAAAAABf470AGsKOJ65Ee9ZxZasRjABVUbdimwfivMloakcKoa20R_guknxp0K7xqYAbLD5IfZ9dUMJP77lKTM6oWRpYl17GHw=='
pw = b'gAAAAABf470AeGuSrJmZEZrBzs8rJEQqiUDUoArQPNSkMJnlaKyxEknOUXvtvpWlLbTqBkq0SnEnYvjadV7gFI1sd7jtJJbImQ=='
# Constructor
def __init__(self, target, haystack_wnd='Toontown Rewritten'):
# Window Capture has default to TTR, else we choose from main.
self.wincap = WindowCapture(window_name=haystack_wnd)
# Previously, we had to use the object to call this function.
# Now that it is static, we can call the class directly.
# wincap.list_window_names()
# WindowCapture.list_window_names()
# check foreground window title
current = self.wincap.title()
"""
The Encryption Method I used:
click.write_key()
key = click.load_key()
message1 = user.encode()
print(message1) - bytes now
message2 = pw.encode()
print(message2)
f = Fernet(key)
encrypted1 = f.encrypt(message1)
encrypted2 = f.encrypt(message2)
print(encrypted1)
print(encrypted2)
"""
# Decrypt our user name and pw. IF you want to use it,
# remove the encryption method, or generate your own encrypted values.
# Add in your own user/pw instead.``
self.key = self.load_key()
f = Fernet(self.key)
# Target is selectable from main file now.
if (current == "Toontown Rewritten Launcher"):
# Make TextBox Bigger
self.vision_target = Vision('TextBox.png')
# empty bits on bitmap, idk how they made the launcher
# self.locator()
# Just send input
pdi.press(['tab'])
time.sleep(0.05)
pdi.typewrite(f.decrypt(self.user).decode())
time.sleep(0.05)
pdi.press(['tab'])
time.sleep(0.05)
pdi.typewrite(f.decrypt(self.pw).decode())
time.sleep(0.05)
pdi.press(['enter'])
time.sleep(0.05)
else:
self.vision_target = Vision(target)
# Only find best match
self.locator(multi=False)
def locator(self, single=False, multi=True):
loop_time = time()
if not single:
while (True):
# screenshot = None
# screenshot = pyautogui.screenshot()
# cv.imshow is not compatable with pyautogui ss format.
# so we use numpy.
# screenshot = ImageGrab.grab()
# screenshot = np.array(screenshot)
# Reversing the RGB values
# screenshot = screenshot[:, :, ::-1].copy()
# More self-documenting version below:
# screenshot = cv.cvtColor(screenshot, cv.COLOR_RGB2BGR)
# screenshot = window_capture()
screenshot = self.wincap.get_screenshot()
# Processed Image shown instead of raw screenshot!
# We show image in our find() function.
# cv.imshow('Computer Vision', screenshot)
# findClickPositions('', screenshot, threshold=0.72, debug_mode='points')
# Show the best match only. Must run find() at least once however.
if not multi:
if not self.firstRun:
bestMatch = self.vision_target.bestMatch()
self.points = self.vision_target.find(
screenshot, bestMatch, 'rectangles')
else:
self.points = self.vision_target.find(
screenshot, 0.9, 'rectangles')
self.firstRun = False
else:
self.points = self.vision_target.find(
screenshot, 0.9, 'rectangles')
# debug the loop rate - bad atm
print('FPS {}'.format(1 / (time() - loop_time)))
loop_time = time()
# Press 'q' with the output window focused to exit.
# Waits 1 ms every loop to process key presses
if cv.waitKey(1) == ord('q'):
cv.destroyAllWindows()
break
# For single uses
else:
screenshot = self.wincap.get_screenshot()
if not multi:
if not self.firstRun:
bestMatch = self.vision_target.bestMatch()
self.points = self.vision_target.find(
screenshot, bestMatch, 'rectangles')
else:
self.points = self.vision_target.find(
screenshot, 0.9, 'rectangles')
self.firstRun = False
else:
self.points = self.vision_target.find(screenshot, 0.9,
'rectangles')
while (True):
if cv.waitKey(1) == ord('q'):
cv.destroyAllWindows()
break
print('Done.')
# Encrypts our user/pw
def write_key(self):
# Generates a key and save it into a file
self.key = Fernet.generate_key()
with open("key.key", "wb") as key_file:
key_file.write(self.key)
def load_key(self):
# Loads the key from the current directory named `key.key`
return open("key.key", "rb").read()
import cv2 as cv
from windowcapture import WindowCapture
import brain
from keyinput import PressKey #https://gist.github.com/tracend/912308
import keyboard
import numpy as np
windowcap = WindowCapture("Trackmania")
recording = False
scaledw = 160
scaledh = int(9 / 16 * scaledw)
saved_actions = np.zeros(
4 + scaledw * scaledh) #= [2,2,2,2]#np.zeros(shape=[0,4],dtype=np.int)
while (True):
screenshot = windowcap.get_screenshot()
resized = cv.resize(screenshot, (scaledw, scaledh),
interpolation=cv.INTER_AREA)
grayscale = cv.cvtColor(resized, cv.COLOR_BGR2GRAY)
flat = np.reshape(grayscale, (scaledw * scaledh))
restored = np.reshape(flat, (scaledh, scaledw))
cv.imshow("screen grab", restored)
if recording:
action = [
int(keyboard.is_pressed('w')),
int(keyboard.is_pressed('a')),
int(keyboard.is_pressed('s')),
int(keyboard.is_pressed('d'))
]
if (abs(np.max(action)) > 1):
continue
class FishingBot:
#properties
fish_pos_x = None
fish_pos_y = None
fish_last_time = None
detect_text_enable = False
botting = False
FISH_RANGE = 74
FISH_VELO_PREDICT = 30
BAIT_POSITION = (473, 750)
FISH_POSITION = (440, 750)
FILTER_CONFIG = [49, 0, 58, 134, 189, 189, 0, 0, 0, 0]
FISH_WINDOW_CLOSE = (430, 115)
# set position of the fish windows
# this value can be diferent by the sizes of the game window
FISH_WINDOW_SIZE = (280, 226)
FISH_WINDOW_POSITION = (163, 125)
wincap = None
fishfilter = Filter() if detect_text_enable else None
# Load the needle image
needle_img = cv.imread('images/fiss.jpg', cv.IMREAD_UNCHANGED)
needle_img_clock = cv.imread('images/clock.jpg', cv.IMREAD_UNCHANGED)
# Some time cooldowns
detect_text = True
# Limit time
initial_time = None
end_time_enable = False
end_time = 0
# for fps
loop_time = time()
# The mouse click cooldown
timer_mouse = time()
# The timer beteween the states
timer_action = time()
bait_time = 2
throw_time = 2
game_time = 2
# This is the filter parameters, this help to find the right image
hsv_filter = HsvFilter(*FILTER_CONFIG)
state = 0
def detect(self, haystack_img):
# match the needle_image with the hasytack image
result = cv.matchTemplate(haystack_img, self.needle_img,
cv.TM_CCOEFF_NORMED)
min_val, max_val, min_loc, max_loc = cv.minMaxLoc(result)
# needle_image's dimensions
needle_w = self.needle_img.shape[1]
needle_h = self.needle_img.shape[0]
# get the position of the match image
top_left = max_loc
bottom_right = (top_left[0] + needle_w, top_left[1] + needle_h)
# Draw the circle of the fish limits
cv.circle(
haystack_img,
(int(haystack_img.shape[1] / 2), int(haystack_img.shape[0] / 2)),
self.FISH_RANGE,
color=(0, 0, 255),
thickness=1)
# Only the max level of match is greater than 0.5
if max_val > 0.5:
pos_x = (top_left[0] + bottom_right[0]) / 2
pos_y = (top_left[1] + bottom_right[1]) / 2
if self.fish_last_time:
dist = math.sqrt((pos_x - self.fish_pos_x)**2 +
(self.fish_pos_y - pos_y)**2)
cv.rectangle(haystack_img,
top_left,
bottom_right,
color=(0, 255, 0),
thickness=2,
lineType=cv.LINE_4)
# Calculate the fish velocity
velo = dist / (time() - self.fish_last_time)
if velo == 0.0:
return (pos_x, pos_y, True)
elif velo >= 150:
# With this velocity the fish position will be predict
pro = self.FISH_VELO_PREDICT / dist
destiny_x = int(pos_x + (pos_x - self.fish_pos_x) * pro)
destiny_y = int(pos_y + (pos_y - self.fish_pos_y) * pro)
# Draw the predict line
cv.line(haystack_img, (int(pos_x), int(pos_y)),
(destiny_x, destiny_y), (0, 255, 0),
thickness=3)
return (destiny_x, destiny_y, False)
# get the fish position and the time
self.fish_pos_x = pos_x
self.fish_pos_y = pos_y
self.fish_last_time = time()
return None
def detect_minigame(self, haystack_img):
result = cv.matchTemplate(haystack_img, self.needle_img_clock,
cv.TM_CCOEFF_NORMED)
min_val, max_val, min_loc, max_loc = cv.minMaxLoc(result)
if max_val > 0.9:
return True
return False
def set_to_begin(self, values):
if values['-ENDTIMEP-']:
self.end_time_enable = True
try:
self.end_time = int(values['-ENDTIME-']) * 60
except:
self.end_time = 0
self.bait_time = values['-BAITTIME-']
self.throw_time = values['-THROWTIME-']
self.game_time = values['-STARTGAME-']
self.wincap = WindowCapture('METIN2')
self.state = 0
self.initial_time = time()
self.timer_action = time()
def runHack(self):
screenshot = self.wincap.get_screenshot()
# crop and aply hsv filter
crop_img = screenshot[
self.FISH_WINDOW_POSITION[1]:self.FISH_WINDOW_POSITION[1] +
self.FISH_WINDOW_SIZE[1],
self.FISH_WINDOW_POSITION[0]:self.FISH_WINDOW_POSITION[0] +
self.FISH_WINDOW_SIZE[0]]
detect_end_img = screenshot[
self.FISH_WINDOW_POSITION[1]:self.FISH_WINDOW_POSITION[1] +
self.FISH_WINDOW_SIZE[1],
self.FISH_WINDOW_POSITION[0]:self.FISH_WINDOW_POSITION[0] +
self.FISH_WINDOW_SIZE[0]]
crop_img = self.hsv_filter.apply_hsv_filter(crop_img)
cv.putText(crop_img, 'FPS: ' + str(1 / (time() - self.loop_time))[:2],
(10, 200), cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv.putText(
crop_img, 'State: ' + str(self.state) + ' ' +
str(time() - self.timer_action)[:5], (10, 160),
cv.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
self.loop_time = time()
# Verify total time
if self.end_time_enable and time() - self.initial_time > self.end_time:
self.botting = False
# State to click put the bait in the rod
if self.state == 0:
mouse_x = int(self.BAIT_POSITION[0] + self.wincap.offset_x)
mouse_y = int(self.BAIT_POSITION[1] + self.wincap.offset_y)
if time() - self.timer_action > self.bait_time:
self.detect_text = True
pydirectinput.click(x=mouse_x, y=mouse_y, button='right')
self.state = 1
self.timer_action = time()
# State to throw the bait
if self.state == 1:
if time() - self.timer_action > self.throw_time:
mouse_x = int(self.FISH_POSITION[0] + self.wincap.offset_x)
mouse_y = int(self.FISH_POSITION[1] + self.wincap.offset_y)
pydirectinput.click(x=mouse_x, y=mouse_y, button='right')
self.state = 2
self.timer_action = time()
# Delay to start the clicks
if self.state == 2:
if time() - self.timer_action > self.game_time:
self.state = 3
self.timer_action = time()
# Countdown to finish the state
detected_end = self.detect_minigame(detect_end_img)
if self.state == 3:
if time() - self.timer_action > 15:
self.timer_action = time()
self.state = 0
if time() - self.timer_action > 5 and detected_end is False:
self.timer_action = time()
self.state = 0
if self.detect_text_enable and time() - self.timer_action > 1.5:
if self.detect_text:
if self.fishfilter.match_with_text(screenshot) is False:
mouse_x = int(self.wincap.offset_x +
self.FISH_WINDOW_CLOSE[0])
mouse_y = int(self.wincap.offset_y +
self.FISH_WINDOW_CLOSE[1])
pydirectinput.click(x=mouse_x,
y=mouse_y,
button='left')
pydirectinput.click(x=mouse_x,
y=mouse_y,
button='left')
self.detect_text = False
# make the click
if (time() -
self.timer_mouse) > 0.3 and self.state == 3 and detected_end:
# Detect the fish
square_pos = self.detect(crop_img)
if square_pos:
# Recalculate the mouse position with the fish position
pos_x = square_pos[0]
pos_y = square_pos[1]
center_x = self.FISH_WINDOW_SIZE[0] / 2
center_y = self.FISH_WINDOW_SIZE[1] / 2
mouse_x = int(pos_x)
mouse_y = int(pos_y)
# Verify if the fish is in range
d = self.FISH_RANGE**2 - ((center_x - mouse_x)**2 +
(center_y - mouse_y)**2)
# Make the click
if (d > 0):
self.timer_mouse = time()
mouse_x = int(pos_x + self.FISH_WINDOW_POSITION[0] +
self.wincap.offset_x)
mouse_y = int(pos_y + self.FISH_WINDOW_POSITION[1] +
self.wincap.offset_y)
pydirectinput.click(x=mouse_x, y=mouse_y)
'''
cv.imshow('Minha Janela', crop_img)
if cv.waitKey(1) == ord('q'):
cv.destroyAllWindows()
return True
'''
return crop_img
class PuzzleBot:
#properties
botting = False
PUZZLE_WINDOW_SIZE = (260, 170)
PUZZLE_WINDOW_POSITION = (270, 227)
PUZZLE_GET_NEW_PIECE = (230, 85)
PUZZLE_COMFIRM = (100, 90)
PUZZLE_GET_NEW_PIECE_COLOR = (110, 150)
wincap = None
tetris = Tetris()
timer_action = time()
get_piece_time = 2
new_piece = None
state = 0
end = False
dictdump = None
def set_to_begin(self, values):
self.wincap = WindowCapture(constants.GAME_NAME)
self.state = 0
with open('pieces_second.json') as handle:
self.dictdump = json.loads(handle.read())
def set_puzzle_state(self, crop_img):
paint_c = 32
board = [[0,0,0,0,0,0],
[0,0,0,0,0,0],
[0,0,0,0,0,0],
[0,0,0,0,0,0]]
for i in range(0, 4):
for j in range(0, 6):
if crop_img[15 + paint_c*i, 15 + paint_c*j, 0] < 50 and crop_img[15 + paint_c*i, 15 + paint_c*j, 1] < 50 and crop_img[15 + paint_c*i, 15 + paint_c*j, 2] < 50:
board[i][j] = 0
else:
board[i][j] = 1
cv.rectangle(crop_img, (15 + paint_c*j, 15 + paint_c*i), (15 + paint_c*j, 15 + paint_c*i),
color=(0, 255, 255), thickness=4, lineType=cv.LINE_4)
self.tetris.board = board
if self.tetris.count_zeros == 0:
self.tetris.first = 0
self.tetris.second = 0
else:
self.tetris.first = 1
self.tetris.second = 1
def get_image(self):
screenshot = self.wincap.get_screenshot()
crop_img = screenshot[self.PUZZLE_WINDOW_POSITION[1]:self.PUZZLE_WINDOW_POSITION[1]+self.PUZZLE_WINDOW_SIZE[1],
self.PUZZLE_WINDOW_POSITION[0]:self.PUZZLE_WINDOW_POSITION[0]+self.PUZZLE_WINDOW_SIZE[0]]
return crop_img
def press_comfirm(self):
mouse_x = int(self.PUZZLE_COMFIRM[0] + self.PUZZLE_WINDOW_POSITION[0] + self.wincap.offset_x)
mouse_y = int(self.PUZZLE_COMFIRM[1] + self.PUZZLE_WINDOW_POSITION[1] + self.wincap.offset_y)
pydirectinput.click(x=mouse_x, y=mouse_y, button='left')
def press_comfirm_cake(self):
mouse_x = int(self.PUZZLE_COMFIRM[0] + 20 + self.PUZZLE_WINDOW_POSITION[0] + self.wincap.offset_x)
mouse_y = int(self.PUZZLE_COMFIRM[1] + self.PUZZLE_WINDOW_POSITION[1] + self.wincap.offset_y)
pydirectinput.click(x=mouse_x, y=mouse_y, button='left')
def throw_pice(self):
mouse_x = int(self.PUZZLE_COMFIRM[0] + self.PUZZLE_WINDOW_POSITION[0] + self.wincap.offset_x)
mouse_y = int(self.PUZZLE_COMFIRM[1] + self.PUZZLE_WINDOW_POSITION[1] + self.wincap.offset_y)
pydirectinput.click(x=mouse_x, y=mouse_y, button='right')
def get_new_piece_color(self, crop_image):
x = int(self.PUZZLE_GET_NEW_PIECE_COLOR[0])
y = int(self.PUZZLE_GET_NEW_PIECE_COLOR[1])
if (crop_image[y, x, 0] > 35 and crop_image[y, x, 0] < 40 and
crop_image[y, x, 1] > 60 and crop_image[y, x, 1] < 70 and
crop_image[y, x, 2] > 240 and crop_image[y, x, 2] < 260):
return 4
elif (crop_image[y, x, 0] > 20 and crop_image[y, x, 0] < 30 and
crop_image[y, x, 1] > 150 and crop_image[y, x, 1] < 170 and
crop_image[y, x, 2] > 240 and crop_image[y, x, 2] < 260):
return 1
elif (crop_image[y, x, 0] > 35 and crop_image[y, x, 0] < 50 and
crop_image[y, x, 1] > 240 and crop_image[y, x, 1] < 260 and
crop_image[y, x, 2] > 35 and crop_image[y, x, 2] < 50):
return 5
elif (crop_image[y, x, 0] > 240 and crop_image[y, x, 0] < 260 and
crop_image[y, x, 1] > 240 and crop_image[y, x, 1] < 260 and
crop_image[y, x, 2] > 20 and crop_image[y, x, 2] < 30):
return 3
elif (crop_image[y, x, 0] > 240 and crop_image[y, x, 0] < 260 and
crop_image[y, x, 1] > 100 and crop_image[y, x, 1] < 115 and
crop_image[y, x, 2] > -10 and crop_image[y, x, 2] < 10):
return 2
elif (crop_image[y, x, 0] > 50 and crop_image[y, x, 0] < 60 and
crop_image[y, x, 1] > 235 and crop_image[y, x, 1] < 255 and
crop_image[y, x, 2] > 250 and crop_image[y, x, 2] < 260):
return 6
def detect_end_game(self, crop_img):
x = int(self.PUZZLE_GET_NEW_PIECE[0])
y = int(self.PUZZLE_GET_NEW_PIECE[1])
if crop_img[y, x, 0] > 100 and crop_img[y, x, 1] > 150 and crop_img[y, x, 2] > 150:
return False
else:
return True
def play_game(self):
piece = Piece(self.new_piece)
decision, pos = self.tetris.find_first(piece, self.dictdump)
paint_c = 32
if decision == 1:
self.tetris.insert_piece(pos[0], pos[1], piece)
if self.tetris.verify_end():
self.end = True
mouse_x = 15 + paint_c*pos[1] + self.PUZZLE_WINDOW_POSITION[0] + self.wincap.offset_x
mouse_y = 15 + paint_c*pos[0] + self.PUZZLE_WINDOW_POSITION[1] + self.wincap.offset_y
pydirectinput.click(mouse_x, mouse_y)
return None
if decision == 2:
return None
possibilites = self.tetris.find_possibles(piece)
pices_count = 0
for i in range(1,7):
if i != piece.piece_type:
possis = self.tetris.find_possibles(Piece(i))
if len(possis):
pices_count += 1
if piece.piece_type == 1 and pices_count != 0:
possibilites = [i for i in possibilites if self.tetris.verify_isolated(i[0], i[1])]
if len(possibilites):
a = self.tetris.choose_better(piece, possibilites)
self.tetris.insert_piece(a[0], a[1], piece)
if self.tetris.verify_end():
self.end = True
mouse_x = 15 + paint_c*a[1] + self.PUZZLE_WINDOW_POSITION[0] + self.wincap.offset_x
mouse_y = 15 + paint_c*a[0] + self.PUZZLE_WINDOW_POSITION[1] + self.wincap.offset_y
pydirectinput.click(mouse_x, mouse_y)
return True
return None
def runHack(self):
crop_image = self.get_image()
timep = 0.2
if self.state == 0:
mouse_x = int(self.PUZZLE_GET_NEW_PIECE[0] + self.PUZZLE_WINDOW_POSITION[0] + self.wincap.offset_x)
mouse_y = int(self.PUZZLE_GET_NEW_PIECE[1] + self.PUZZLE_WINDOW_POSITION[1] + self.wincap.offset_y)
if time() - self.timer_action > timep:
if self.detect_end_game(crop_image):
self.botting = False
return None
pydirectinput.click(x=mouse_x, y=mouse_y, button='left')
self.state = 1
self.timer_action = time()
if self.state == 1:
if time() - self.timer_action > timep:
self.press_comfirm()
self.state = 2
self.timer_action = time()
if self.state == 2:
mouse_x = int(self.PUZZLE_GET_NEW_PIECE_COLOR[0] + self.PUZZLE_WINDOW_POSITION[0] + self.wincap.offset_x)
mouse_y = int(self.PUZZLE_GET_NEW_PIECE_COLOR[1] + self.PUZZLE_WINDOW_POSITION[1] + self.wincap.offset_y)
if time() - self.timer_action > timep:
self.state = 4
self.timer_action = time()
pydirectinput.moveTo(mouse_x, mouse_y)
if self.state == 4:
if time() - self.timer_action > timep:
self.state = 5
self.timer_action = time()
self.new_piece = self.get_new_piece_color(crop_image)
if self.state == 5:
if time() - self.timer_action > timep:
self.timer_action = time()
self.set_puzzle_state(crop_image)
if self.play_game():
self.state = 6
else:
self.state = 7
if self.state == 6:
if time() - self.timer_action > timep:
self.press_comfirm()
self.timer_action = time()
if self.end:
self.state = 9
else:
self.state = 0
if self.state == 7:
if time() - self.timer_action > timep:
self.throw_pice()
self.timer_action = time()
self.state = 8
if self.state == 8:
if time() - self.timer_action > timep:
self.press_comfirm()
self.timer_action = time()
self.state = 0
if self.state == 9:
if time() - self.timer_action > 2:
self.end = False
self.press_comfirm_cake()
self.timer_action = time()
self.state = 0
return None
def main():
#if (GetWindowText(GetForegroundWindow()) == 'Battlefield™ V'):
print("welcoming message coming")
welcome_threading()
# initialize the WindowCapture class
wincap = WindowCapture('Battlefield™ V')
loop_time = time()
sg.theme('DarkAmber') # Add a touch of color
# All the stuff inside your window.
# Create the Window
window = sg.Window('OFC administrator', layout)
# Event Loop to process "events" and get the "values" of the inputs
while(True):
event, values = window.read()
if event == 'Send':
print('ok')
send_message(values['global_message'])
print(sg.Checkbox.get)
if event == sg.WIN_CLOSED or event == 'Cancel': # if user closes window or clicks cancel
break
print('You entered ', values[0])
window.close()
if (GetWindowText(GetForegroundWindow()) == 'Battlefield™ V'):
screenshot = wincap.get_screenshot()
# data = process_screen_shot(screenshot)
# kill_logs = process_kill_shot(screenshot)
# #menue = process_menue_shot(screenshot)
# commands(data)
# kill_log(kill_logs)
# proc_tick = process_tickets(screenshot)
# ticket_data(proc_tick)
# scoreboard = process_scoreboard(screenshot)
# score_board_data(scoreboard)
#commands(menue)
#send_message(welcoming)
# Button("QUIT", (100, 400), quit)
#cv.imshow('Computer Vision', screenshot)
# debug the loop rate
#print('FPS {}'.format(1.0 / (time() - loop_time)))
loop_time = time()
# press 'q' with the output window focused to exit.
# waits 1 ms every loop to process key presses
if cv.waitKey(1) == ord('q'):
pydirectinput.keyUp('ctrl')
pydirectinput.keyUp('v')
data =''
cv.destroyAllWindows()
break
print('Done.')
