def resetar():
for i in re.sub('[^0-9]', '', cortar_e_ocr((1350, 380, 50, 20))):
busca_por_imagem(i)
ahk = AHK(executable_path='./ahk_folder/AutoHotkeyA32.exe')
ahk.mouse_move(x=1149, y=649)
ahk.click(direction='down')
time.sleep(0.008)
ahk.click(direction='up')
def uppar():
ahk = AHK(executable_path='./ahk_folder/AutoHotkeyA32.exe')
while True:
if re.sub('[^0-9]', '', cortar_e_ocr((930, 200, 50, 20))) != '600':
ahk.mouse_move(1828, 791)
ahk.click(direction='down')
else:
ahk.click(direction='up')
break
def busca_por_imagem(name_img):
pos = imagesearch(f"./data/{name_img}.JPG")
img = cv2.imread(f"./data/{name_img}.JPG")
size = img.shape
print(size)
if pos[0] != -1:
ahk = AHK(executable_path='./ahk_folder/AutoHotkeyA32.exe')
ahk.mouse_move(x=pos[0] + (size[1] / 2), y=pos[1] + (size[0] / 2))
ahk.click(direction='down')
time.sleep(0.008)
ahk.click(direction='up')
else:
busca_por_imagem(name_img)
class Controller:
def __init__(self):
self.mouse = AHK()
self.keyboard = None #KeyboardController()
def random_walk(self):
offset_x = 3
offset_y = 22
center_x = (1024 + offset_x) / 2
center_y = (768 + offset_y) / 2
range = 150
x = center_x + randint(-range, range)
y = center_y + randint(-range, range)
self.mouse.mouse_move(x=x, y=y, speed=3, blocking=True)
time.sleep(0.5)
self.mouse.click(x, y)
time.sleep(0.5)
def atacar(self, x, y):
x += 25
y += 25
print("About to attack")
self.mouse.mouse_position = (x, y)
time.sleep(0.2)
self.mouse.click()
time.sleep(5)
def skill_F1(self):
self.mouse.mouse_position = (235, 41)
time.sleep(0.2)
self.mouse.click()
time.sleep(0.2)
self.mouse.click()
[[2470, 1320], [2495, 1340]]
]
pc_type = input("Desktop or Laptop?")
if pc_type.upper() == "DESKTOP":
inventory = desktop_inventory
elif pc_type.upper() == "LAPTOP":
# Need to add pixels for laptop
inventory = 'laptop inventory'
def get_random_coords(coords):
random_x = randint(coords[0][0], coords[1][0])
random_y = randint(coords[0][1], coords[1][1])
return [random_x, random_y]
sleep(5)
for slot_coords in inventory:
random_enchant_coords = get_random_coords(enchant_four)
random_slot_coords = get_random_coords(slot_coords)
ahk.mouse_move(random_enchant_coords[0], random_enchant_coords[1])
ahk.click()
sleep(uniform(0.2, 0.5))
ahk.mouse_move(random_slot_coords[0], random_slot_coords[1])
ahk.click()
sleep(uniform(1.2, 1.5))
class WindowControl:
def __init__(self, window_title: str) -> "WindowControl":
self.autohotkey = AHK()
self.window = self.autohotkey.find_window(title=window_title.encode("utf-8"))
if not self.window:
settings.LOGGER.error(f"Window {window_title} not found")
def activate(self) -> None:
"""
Activate window i.e. bring it to front.
"""
if self.window:
self.window.activate()
def send_click(
self,
click_position_x_percentage_from_origin: Union[int, float],
click_position_y_percentage_from_origin: Union[int, float],
) -> bool:
"""
:param click_position_x_percentage_from_origin: X position as percentage from window origin that should be clicked
:param click_position_y_percentage_from_origin: Y position as percentage from window origin that should be clicked
:return: True if click was sent to the window
"""
if self.window:
self.activate()
if (
click_position_x_percentage_from_origin is not None
and click_position_y_percentage_from_origin is not None
):
click_x, click_y = self._click_window_position(
click_position_x_percentage_from_origin,
click_position_y_percentage_from_origin,
)
settings.LOGGER.warning(
f"Clicked {click_x}, {click_y} of window {self.window.title}"
)
return True
return False
def send_drag(
self,
from_position_x_percentage_from_origin: Union[int, float],
from_position_y_percentage_from_origin: Union[int, float],
to_position_x_percentage_from_origin: Union[int, float],
to_position_y_percentage_from_origin: Union[int, float],
) -> bool:
"""
Drag mouse over window.
:param from_position_x_percentage_from_origin: X position as percentage from window origin from where the mouse drag should start
:param from_position_y_percentage_from_origin: Y position as percentage from window origin from where the mouse drag should start
:param from_position_x_percentage_from_origin: X position as percentage from window origin to where the mouse drag should end
:param from_position_y_percentage_from_origin: Y position as percentage from window origin to where the mouse drag should end
:return: True if mouse drag was sent to the window
"""
if self.window:
self.activate()
if (
from_position_x_percentage_from_origin is not None
and from_position_y_percentage_from_origin is not None
and to_position_x_percentage_from_origin is not None
and to_position_y_percentage_from_origin is not None
):
from_x, from_y, to_x, to_y = self._drag_mouse_inside_window(
from_position_x_percentage_from_origin,
from_position_y_percentage_from_origin,
to_position_x_percentage_from_origin,
to_position_y_percentage_from_origin,
)
settings.LOGGER.warning(
f"Dragged mouse from {from_x}, {from_y} to {to_x}, {to_y} inside window {self.window.title}"
)
return True
return False
def send_key(
self,
command: str,
click_position_x_percentage_from_origin: int,
click_position_y_percentage_from_origin: int,
) -> bool:
"""
Send given command (keys)
:param command: keys to send
:param click_position_x_percentage_from_origin: X position as percentage from window origin that should be clicked
:param click_position_y_percentage_from_origin: Y position as percentage from window origin that should be clicked
:return: True if keys were sent to the window
"""
if self.window:
self.activate()
if (
click_position_x_percentage_from_origin is not None
and click_position_y_percentage_from_origin is not None
):
self._click_window_position(
click_position_x_percentage_from_origin,
click_position_y_percentage_from_origin,
)
self._send_key(command)
settings.LOGGER.warning(f"Sent {command} to window {self.window.title}")
return True
return False
def _calculate_click_position(
self,
x: int,
y: int,
width: int,
height: int,
click_position_x_percentage_from_origin: Union[int, float] = 0,
click_position_y_percentage_from_origin: Union[int, float] = 0,
) -> Tuple[Union[int, float], Union[int, float]]:
"""
Calculate a screen position (x, y) that is going to be clicked.
:param x: X position of window
:param y: Y position of window
:param width: Window width
:param height: Window height
:param click_position_x_percentage_from_origin: X position as percentage from window XY origin that should be clicked, defaults to 0
:param click_position_y_percentage_from_origin: Y position as percentage from window XY origin that should be clicked, defaults to 0
:return: x, y position in screen to click as tuple
:raises ValueError: x or y position can't be converted to float or is nan
"""
return (
float_or_raise(x + width * click_position_x_percentage_from_origin / 100),
float_or_raise(
y + (height - height * click_position_y_percentage_from_origin / 100)
),
)
def _click_window_position(
self,
click_position_x_percentage_from_origin: Union[int, float] = 0,
click_position_y_percentage_from_origin: Union[int, float] = 0,
) -> Tuple[Union[int, float], Union[int, float]]:
"""
Click a position (x, y from origin) in the window.
:param click_position_x_percentage_from_origin: X position as percentage from window XY origin that should be clicked, defaults to 0
:param click_position_y_percentage_from_origin: Y position as percentage from window XY origin that should be clicked, defaults to 0
:return: x, y position in screen that was clicked as tuple
"""
click_x, click_y = self._calculate_click_position(
*self.window.rect,
click_position_x_percentage_from_origin,
click_position_y_percentage_from_origin,
)
settings.LOGGER.warning(
f"Moving mouse and clicking to {click_x}, {click_y} inside window {self.window.title}"
)
self.autohotkey.click(click_x, click_y, blocking=True)
return (click_x, click_y)
def _drag_mouse_inside_window(
self,
from_position_x_percentage_from_origin: Union[int, float],
from_position_y_percentage_from_origin: Union[int, float],
to_position_x_percentage_from_origin: Union[int, float],
to_position_y_percentage_from_origin: Union[int, float],
) -> Tuple[
Union[int, float], Union[int, float], Union[int, float], Union[int, float]
]:
"""
Drag mouse over window.
:param from_position_x_percentage_from_origin: X position as percentage from window origin from where the mouse drag should start
:param from_position_y_percentage_from_origin: Y position as percentage from window origin from where the mouse drag should start
:param from_position_x_percentage_from_origin: X position as percentage from window origin to where the mouse drag should end
:param from_position_y_percentage_from_origin: Y position as percentage from window origin to where the mouse drag should end
:return: drag position from x, y to x, y as tuple
"""
rect = self.window.rect
from_x, from_y = self._calculate_click_position(
*rect,
from_position_x_percentage_from_origin,
from_position_y_percentage_from_origin,
)
to_x, to_y = self._calculate_click_position(
*rect,
to_position_x_percentage_from_origin,
to_position_y_percentage_from_origin,
)
settings.LOGGER.warning(
f"Dragging mouse from {from_x}, {from_y} to {to_x}, {to_y} inside window {self.window.title}"
)
self.autohotkey.mouse_drag(
to_x, to_y, from_position=(from_x, from_y), blocking=True
)
return (from_x, from_y, to_x, to_y)
def _send_key(self, command) -> None:
"""
Send given keys to window.
"""
self.window.send(command, blocking=True)
class BoardAPI:
"""
def __init__(self, point_top_right, point_top_left, point_bottom_right, point_bottom_left):
# point format (x, y) tuple type
top = point_top_right[1]
bottom = point_bottom_right[1]
left = point_top_left[0]
right = point_top_right[0]
self.point_top_right = point_top_right
if (point_top_left[1] != top):
point_top_left = (left, top)
self.point_top_left = point_top_left
if (point_bottom_right[0] != right ):
point_bottom_right = (right, bottom)
self.point_bottom_right = point_bottom_right
if (point_bottom_left[0] != left or point_bottom_left[1] != bottom):
point_bottom_left = (left, bottom)
self.point_bottom_left = point_bottom_left
"""
def __init__(self, point_top_right, length, playing_color):
self.point_top_right = point_top_right
self.point_top_left = (point_top_right[0] + length, point_top_right[1])
self.point_bottom_right = (point_top_right[0],
point_top_right[1] + length)
self.point_bottom_left = (point_top_right[0] + length,
point_top_right[1] + length)
self.board = chess.Board()
# to detect rival move
self.previous_board_state = {
'a8': ('black', 'R'),
'b8': ('black', 'N'),
'c8': ('black', 'B'),
'd8': ('black', 'Q'),
'e8': ('black', 'K'),
'f8': ('black', 'B'),
'g8': ('black', 'N'),
'h8': ('black', 'R'),
'a7': ('black', 'P'),
'b7': ('black', 'P'),
'c7': ('black', 'P'),
'd7': ('black', 'P'),
'e7': ('black', 'P'),
'f7': ('black', 'P'),
'g7': ('black', 'P'),
'h7': ('black', 'P'),
'a6': None,
'b6': None,
'c6': None,
'd6': None,
'e6': None,
'f6': None,
'g6': None,
'h6': None,
'a5': None,
'b5': None,
'c5': None,
'd5': None,
'e5': None,
'f5': None,
'g5': None,
'h5': None,
'a4': None,
'b4': None,
'c4': None,
'd4': None,
'e4': None,
'f4': None,
'g4': None,
'h4': None,
'a3': None,
'b3': None,
'c3': None,
'd3': None,
'e3': None,
'f3': None,
'g3': None,
'h3': None,
'a2': ('white', 'P'),
'b2': ('white', 'P'),
'c2': ('white', 'P'),
'd2': ('white', 'P'),
'e2': ('white', 'P'),
'f2': ('white', 'P'),
'g2': ('white', 'P'),
'h2': ('white', 'P'),
'a1': ('white', 'R'),
'b1': ('white', 'N'),
'c1': ('white', 'B'),
'd1': ('white', 'Q'),
'e1': ('white', 'K'),
'f1': ('white', 'B'),
'g1': ('white', 'N'),
'h1': ('white', 'R')
}
self.playing_color = playing_color
self.ahk = AHK()
def init(self):
self.previous_board_state = self.get_figures_pos()
def get_rival_color(self):
map_color = {"white": "black", "black": "white"}
return map_color[self.playing_color]
def get_A(self):
return abs(self.point_bottom_right[1]) - abs(self.point_top_right[1])
def get_B(self):
return abs(self.point_top_left[0]) - abs(self.point_top_right[0])
def get_C(self):
return abs(self.point_bottom_left[1]) - abs(self.point_top_left[1])
def get_D(self):
return abs(self.point_bottom_left[0]) - abs(self.point_bottom_right[0])
def save_image_of_board(self, filepath):
# part of the screen
im = ImageGrab.grab(bbox=(self.point_top_right[0],
self.point_top_right[1],
self.point_bottom_left[0],
self.point_bottom_left[1])) # X1,Y1,X2,Y2
# save image file
im.save(filepath)
def _slice_images(self, filepath, dirpath):
# white case
board_coord_map_col = {
1: "8",
2: "7",
3: "6",
4: "5",
5: "4",
6: "3",
7: "2",
8: "1"
}
board_coord_map_row = {
1: "a",
2: "b",
3: "c",
4: "d",
5: "e",
6: "f",
7: "g",
8: "h"
}
# black case
if (self.playing_color == "black"):
board_coord_map_col = {
1: "1",
2: "2",
3: "3",
4: "4",
5: "5",
6: "6",
7: "7",
8: "8"
}
board_coord_map_row = {
1: "h",
2: "g",
3: "f",
4: "e",
5: "d",
6: "c",
7: "b",
8: "a"
}
tiles = slice(filepath, 64, 8, 8, False)
result = []
for tile in tiles:
filepath = dirpath
filename = f"{board_coord_map_row[tile.row]}{board_coord_map_col[tile.column]}.png"
fullpath = os.path.join(filepath, filename)
tile.save(fullpath)
result.append(fullpath)
return result
def get_figures_pos(self, debug=False):
"""[summary]
returns dict with figures and possitions
possitions as keys and figures as value
"""
result = {}
with tempfile.TemporaryDirectory() as tmpdirname:
filepath = os.path.join(tmpdirname, "board.png")
self.save_image_of_board(filepath)
tiles_pathes = self._slice_images(filepath, tmpdirname)
for tile in tiles_pathes:
figure = self.recognize_figure(tile)
tile_location = Path(tile).stem
result[tile_location] = figure
if (debug):
print(tmpdirname)
input(f"press any button {__name__}")
return result
def _get_figures_pos(self, debug=True):
result = {}
tmpdirname = tempfile.mkdtemp()
if True:
filepath = os.path.join(tmpdirname, "board.png")
self.save_image_of_board(filepath)
tiles_pathes = self._slice_images(filepath, tmpdirname)
for tile in tiles_pathes:
figure = self.recognize_figure(tile)
tile_location = Path(tile).stem
result[tile_location] = figure
if (debug):
print(tmpdirname)
input(f"press any button {__name__}")
return result
def get_board_state_fen(self, debug=False):
return self.board.fen()
def recognize_figure(self, filepath):
# output format (1 or 2, "letter")
result = None
which_color = {
"(248, 248, 248)": "white", # whie color
"(86, 83, 82)": "black" # black color
}
approx_pixel_count_map = {
"K": 2171,
"Q": 1865,
"R": 1507,
"B": 1365,
"N": 1677,
"P": 978
}
coef_map = {
"K": 4.15707,
"Q": 4.91825,
"R": 5.98871,
"B": 6.61172,
"N": 5.18163,
"P": 9.22801
}
im = Image.open(filepath)
pixels = list(im.getdata())
width, height = im.size
pixels = [pixels[i] for i in range(height * width)]
unique_pixels = list(set(pixels))
pixel_count = {}
for pixel in unique_pixels:
if (pixels.count(pixel) > 20):
pixel_count[str(pixel)] = pixels.count(pixel)
# create difference dict
difference_dict = {}
# find main color
figure_color = None
main_color_pixel = None
for pixel in pixel_count:
if pixel in which_color:
figure_color = which_color[pixel]
main_color_pixel = pixel
if figure_color is not None:
# get subtraction of main color
for figure_letter in approx_pixel_count_map:
# write into difference dict as differ as key and letter as value
# amount_of_pixels = width * height
# coefficient = amount_of_pixels / pixel_count[main_color_pixel]
# difference = abs(coefficient - coef_map[figure_letter])
# difference_dict[difference] = figure_letter
# working
difference = abs(pixel_count[main_color_pixel] -
approx_pixel_count_map[figure_letter])
difference_dict[difference] = figure_letter
diff_list = list(difference_dict.keys())
diff_list.sort()
print(
f"recognize_figure: filepath = {filepath} diffrenece dict = ")
print(difference_dict)
print(f"sorted values: {diff_list}")
print()
figure_letter = difference_dict[diff_list[0]]
result = (figure_color, figure_letter)
return result
def _click_on_tile(self, tile_location: str):
# white case
letter_map = {
"a": 0,
"b": 1,
"c": 2,
"d": 3,
"e": 4,
"f": 5,
"g": 6,
"h": 7
}
number_map = {
"8": 0,
"7": 1,
"6": 2,
"5": 3,
"4": 4,
"3": 5,
"2": 6,
"1": 7
}
# black case
if (self.playing_color == "black"):
letter_map = {
"a": 7,
"b": 6,
"c": 5,
"d": 4,
"e": 3,
"f": 2,
"g": 1,
"h": 0
}
number_map = {
"8": 7,
"7": 6,
"6": 5,
"5": 4,
"4": 3,
"3": 2,
"2": 1,
"1": 0
}
length = self.get_A()
length_of_tile = length / 8
# init X Y values which will be added to point top right
# set X to letter_sequence * width + (width/8/2)
X = letter_map[tile_location[0]] * length_of_tile + (length_of_tile /
2)
# set Y to number * height + (height/8/2)
Y = number_map[tile_location[1]] * length_of_tile + (length_of_tile /
2)
# add to point top rigth X and Y
coords = (self.point_top_right[0] + X, self.point_top_right[1] + Y)
print(X)
print(Y)
print(coords)
# click with this coords on screen
self.ahk.click(coords[0], coords[1])
# get rid of cursor
self.ahk.mouse_move(0, 0)
def move_figure_from_to(self, coords: str):
"""[summary]
Args:
coords (str): e5e1 this is an example of coords
"""
print(f" move_figure_from_to coords is {coords}")
print(f"before:\n{self.board}")
self._click_on_tile(coords[:2])
self._click_on_tile(coords[2:])
self.board.push_uci(coords)
# TODO optimize this shit, if it s needed due to optimazation problem with this method
self.previous_board_state = self.get_figures_pos()
print(f"after:\n{self.board}")
def update_board_after_rival_move(self):
print("update_board_after_rival_move")
print(f"before:\n{self.board}")
moveuci = self.get_rivals_move()
self.board.push_uci(moveuci)
self.previous_board_state = self.get_figures_pos()
print(f"after:\n{self.board}")
def is_my_turn(self):
turn_dict = {chess.BLACK: "black", chess.WHITE: "white"}
return turn_dict[self.board.turn] == self.playing_color
def get_rivals_move(self):
# get new board state
new_board_state = self.get_figures_pos()
# check if it s catstling
castling_tiles_map = {
"white": {
'K': ['e1', 'g1'],
'Q': ['c1', 'd1']
},
"black": {
'K': ['e8', 'g8'],
'Q': ['c8', 'd8']
}
}
# check castling rivals tiles from King side
print("get_rival_move: check for castling k side")
k_side_castle = castling_tiles_map[self.get_rival_color()]['K']
if new_board_state[
k_side_castle[1]] != None and self.previous_board_state[
k_side_castle[0]] != None:
first_check = new_board_state[k_side_castle[1]][
1] == 'K' and new_board_state[k_side_castle[0]] == None
second_check = self.previous_board_state[
k_side_castle[1]] == None and self.previous_board_state[
k_side_castle[0]][1] == 'K'
if first_check and second_check:
return ''.join(k_side_castle)
print("nope this is not the case")
# check castling rivals tiles from Queen side
print("get_rival_move: check for castling q side")
q_side_castle = castling_tiles_map[self.get_rival_color()]['Q']
if new_board_state[q_side_castle[0]] != None and new_board_state[
q_side_castle[1]] != None:
first_check = new_board_state[q_side_castle[0]][
1] == 'K' and new_board_state[q_side_castle[1]][1] == 'R'
second_check = self.previous_board_state[q_side_castle[
0]] == None and self.previous_board_state[q_side_castle[1]]
if first_check and second_check:
return ''.join(q_side_castle)
print("this is also not the case")
# else go ahead
# check for en passant
# get en passant fen str from board
en_passant = self.board.fen().split(" ")[3]
if en_passant != '-':
# if on that tile is a pawn, then check where is was
positions = list(new_board_state.keys())
prev_pos = None
# get position, comparing new and old states, of empty tile
for position in positions:
# where no figure there is coords for first part
existing_check = new_board_state[position] == None
generic_check = new_board_state[
position] != self.previous_board_state[position]
if generic_check and existing_check and en_passant[
0] not in position:
prev_pos = position
logging.debug(
f"Comparing En passant new board state[pos] = {new_board_state[position]} prev pos = {self.previous_board_state[position]}, pos appended = {position} "
)
return position + prev_pos
# concate en passant str with pawn prev pos
# return this
# else go ahead
# compare every single position on board with new board state
positions = list(new_board_state.keys())
changed_pos = []
# get position, comparing new and old states, of empty tile
for position in positions:
# where no figure there is coords for first part
existing_check = new_board_state[position] == None
generic_check = new_board_state[
position] != self.previous_board_state[position]
if generic_check and existing_check:
changed_pos.append(position)
logging.debug(
f"Comparing None new board state[pos] = {new_board_state[position]} prev pos = {self.previous_board_state[position]}, pos appended = {position} "
)
# get figure that moved and new pos of this figure
for position in positions:
# where figure appeared there is coords for second part
if (new_board_state[position] != None):
color_check = new_board_state[position][
0] == self.get_rival_color()
generic_check = new_board_state[
position] != self.previous_board_state[position]
if generic_check and color_check:
changed_pos.append(position)
logging.debug(
f"Comparing figure new board state[pos] = {new_board_state[position]} prev pos = {self.previous_board_state[position]}, pos appended = {position} "
)
# get two difference positions of rivals figures
move = ''.join(changed_pos)
if (move == ''):
move = None
# promotion in chess, if pawn manage to get to the other side of a board
# TODO there some bug where Knight recognized as Queen in some cases
# have no idea how to fix that so I jsut bodge this
if self.previous_board_state[changed_pos[0]][1] != new_board_state[
changed_pos[1]][1] and self.previous_board_state[
changed_pos[0]][1] == 'P':
print(
f"promotion check: prev on '{changed_pos[0]}' = {self.previous_board_state[changed_pos[0]]}, new on '{changed_pos[1]}' = {new_board_state[changed_pos[1]]}"
)
print(self.previous_board_state)
print(new_board_state)
move += new_board_state[changed_pos[1]][1].lower()
return move
resetClickLoc = ()
while True:
resetClickLoc = ahk.image_search(
image_path='ReferenceImages\\reference.png',
color_variation=70,
upper_bound=[winX, winY],
lower_bound=[winX2, winY2])
if resetClickLoc is not None:
break
resetClickLoc = ahk.image_search(image_path='ReferenceImages\\reference.png',
color_variation=70,
upper_bound=[winX, winY],
lower_bound=[winX2, winY2])
ahk.click(resetClickLoc[0], resetClickLoc[1])
# Pause to make sure the computer has time to rescan the login screen after mouse is moved off the username button
time.sleep(0.1)
userLoc = ahk.image_search(image_path='ReferenceImages\\usernameBox.jpg',
color_variation=70,
upper_bound=[winX, winY],
lower_bound=[winX2, winY2])
ahk.click(userLoc[0] + 150, userLoc[1] + 30)
# ahk.type() doesn't work for equal signs
ag.write(userName)
passLoc = ahk.image_search(image_path='ReferenceImages\\passwordBox.jpg',
color_variation=70,
upper_bound=[winX, winY],
state = np.array([None] * 22)
#dqn_agent = DQN()
with open('model_pickle', 'rb') as f:
dqn_agent = pickle.load(f)
new_state = np.reshape([None] * 22, [1, 22])
empty_state = np.reshape([None] * 22, [1, 22])
#win.close()
time.sleep(1)
#print(ahk.mouse_position)
#(1058, 153)#select game.
#(977, 94) play button
#time.sleep(1000)
while (True):
#ahk.key_press('.') #advance frame
ahk.click(357, 749) #open dolphin
time.sleep(3)
#win = ahk.find_window(title=b'Dolphin 5.0-10222')
time.sleep(5)
#win.move(x=865, y=0, width=500, height=500)
time.sleep(1)
#(1058, 153)#select game.
#(1015, 94) play button
ahk.click(1058, 153)
time.sleep(1)
ahk.click(1015, 94)
time.sleep(15)
ahk.key_press('.')
# Keys
coord0 = (907, 401)
coord1 = (1016, 399)
coord2 = (1098, 488)
coord3 = (1082, 594)
coord4 = (1016, 675)
coord5 = (895, 686)
coord6 = (837, 590)
coord7 = (838, 482)
center = (960, 540)
coords = [coord0, coord1, coord2, coord3, coord4, coord5, coord6, coord7]
index = -1
## Experiment ##
# Calibration
time.sleep(10)
ahk.key_press('space') # Press and release a key
while index < 345:
index = index + 1
resp = random.randint(0, 7)
time.sleep(1.2)
ahk.click(coords[resp][0], coords[resp][1])
time.sleep(0.5)
ahk.click(center[0], center[1])
os.makedirs(newpath)
else:
continue
'''
cur_dir = 18
region_dbg.clear()
screenshot = ImageGrab.grab(bbox=(517, 110, 1418, 814))
# to file
#screenshot.save('test_images/log/{0}/000.png'.format(cur_dir))
# step-0: AHK执行，获取屏幕
#ahk.double_click(1205, 423) #+价输入框
#输入自定义数值+400
#ahk.send_input('400')
ahk.click(1327, 421)
#点击按钮弹出对话框
ahk.click(1325, 534)
#time.sleep(0.4)
p0_x = 950
p0_y = 358
p1_x = 1370
p1_y = 640
screenshot = ImageGrab.grab(bbox=(p0_x, p0_y, p1_x, p1_y))
# to file
#screenshot.save('test_images/log/{0}/001.png'.format(cur_dir))
started = time.time()
class InputAutomator(webdriver.Ie):
options = webdriver.IeOptions()
user_agent = 'Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko'
options.add_argument(f'user-agent={user_agent}')
options.add_argument("IgnoreZoomLevel=true")
def __init__(self, *args, **kwargs):
kwargs['executable_path'] = 'IEDriverServer.exe'
kwargs['ie_options'] = self.options
super().__init__(*args, **kwargs)
self.maximize_window()
self.ahk = AHK(executable_path="AutoHotkeyU64.exe")
def adjust_coordinates(self, x, y):
"""
Adjusts document coordinates given by selenium to screen coordinates used by AHK.
:param x: x coordinate (pixels) in document
:param y: y coordinate (pixels) in document
:return: (x_adj, y_adj)
"""
window_pos = self.get_window_position()
browser_navigation_panel_height = self.execute_script(
'return window.outerHeight - window.innerHeight;')
return x + window_pos['x'], y + window_pos[
'y'] + browser_navigation_panel_height
def move_rand(self, elem_type, elem_text, x_offset=0, y_offset=0):
"""
Moves mouse to a given element using a random walk path. Does not seem to make a difference.
:param elem_type: one of "class", "css" or "id"
:param elem_text: value of "class", "css" or "id"
:param x_offset: x offset from element coordinates for final mouse position
:param y_offset: y offset from element coordinates for final mouse position
"""
try:
if elem_type == "class":
out = self.find_element_by_class_name(elem_text).location
elif elem_type == "css":
out = self.find_element_by_css_selector(elem_text).location
elif elem_type == "id":
out = self.find_element_by_class_name(elem_text).location
else:
raise ValueError("Unknown elem_type: must be class, css or id")
except (NoSuchElementException, TimeoutException, JavascriptException):
return False
x_final, y_final = self.adjust_coordinates(out['x'] + x_offset,
out['y'] + y_offset)
x0, y0 = self.ahk.mouse_position
x_path, y_path = constrained_walk_2d((x0, y0), (x_final, y_final))
# Reduce points
x_path = x_path[:1] + x_path[::max([len(x_path) //
50, 1])] + x_path[-1:]
y_path = y_path[:1] + y_path[::max([len(y_path) //
50, 1])] + y_path[-1:]
for x, y in zip(x_path, y_path):
self.ahk.run_script(f"SetMouseDelay, -1\nMouseMove, {x}, {y} , 0")
# self.ahk.mouse_move(x=x, y=y, blocking=True, speed=0)
def move_to(self, elem_type, elem_text, x_offset=0, y_offset=0):
self.maximize_window()
"""
Moves mouse to a given element directly. Passes reCAPTCHA.
:param elem_type: one of "class", "css" or "id"
:param elem_text: value of "class", "css" or "id"
:param x_offset: x offset from element coordinates for final mouse position
:param y_offset: y offset from element coordinates for final mouse position
"""
try:
if elem_type == "class":
out = self.find_element_by_class_name(elem_text).location
elif elem_type == "css":
out = self.find_element_by_css_selector(elem_text).location
elif elem_type == "id":
out = self.find_element_by_class_name(elem_text).location
else:
raise ValueError("Unknown elem_type: must be class, css or id")
self.ahk.mouse_move(*self.adjust_coordinates(
out['x'] + x_offset, out['y'] + y_offset),
speed=10,
blocking=True)
return True
except (NoSuchElementException, TimeoutException, JavascriptException):
return False
def click(self):
self.ahk.click()
def type(self, text):
self.ahk.send_input(text)
def scroll(self, direction, times):
[self.ahk.mouse_wheel(direction) for i in range(times)]
def wait_for(self, elem_type, elem_text, timeout=15):
result = False
start = time()
while not result and time() - start < timeout:
try:
if elem_type == "class":
result = self.find_element_by_class_name(
elem_text).is_displayed()
elif elem_type == "css":
result = self.find_element_by_css_selector(
elem_text).is_displayed()
elif elem_type == "id":
result = self.find_element_by_class_name(
elem_text).is_displayed()
return result
except (NoSuchElementException, TimeoutException,
JavascriptException):
result = False
sleep(0.1)
if not result:
print(f"Warn: Element {elem_text} not found after {timeout} sec")
return result
# Keys
coord0 = (907, 401)
coord1 = (1016, 399)
coord2 = (1098, 488)
coord3 = (1082, 594)
coord4 = (1016, 675)
coord5 = (895, 686)
coord6 = (837, 590)
coord7 = (838, 482)
center = (960, 540)
coords = [coord0, coord1, coord2, coord3, coord4, coord5, coord6, coord7]
ahk.click(907, 401) # Blocks until mouse finishes moving (the default)
index = -1
## Experiment ##
# Calibration
time.sleep(10)
ahk.key_press('space') # Press and release a key
while index < 10:
index = index + 1
time.sleep(1)
resp = random.randint(0, 7)
ahk.click(coords[resp][0], coords[resp][1])
time.sleep(5)
