import random import cv2 as cv import numpy as np import pydirectinput from utils import mse from utils import get_click_point from hsvfilter import HsvFilter from game_base_class import GameBase GREEN = 1 YELLOW = 2 RED = 3 BLUE = 4 PURPLE = 5 RAINBOW = 6 BIGBOMB = 7 BOMB = 8 ARROW_DOWN = 9 ARROW_RIGHT = 10 ROCK_1 = 11 ROCK_2 = 12 ROCK_3 = 13 BURGER = 14 PAB1 = 15 GOLDBAR = 16 MAGINENT = 21 CHEMTRANT = 22 TENESENT = 23 CIBUTRANT = 24 ARTISENT = 25 STATUS_FOUND_CONTINUATION = "1" STATUS_FOUND_DEADEND = "2" STATUS_FOUND_ENDING = "3" RAINBOW_STRATEGY = 11 BIGBOMB_STRATEGY = 9 ROCKET_STRATEGY = 7 BOMB_STRATEGY = 5 class Crops(GameBase): def __init__(self, overlay): super().__init__(overlay) self.screenshot = [] self.needles = {} self.hsh_needles = {} self.colors.append(PURPLE) self.current_strategy = overlay.get_strategy_value_as_int() self.fill_data_coordinates() self.set_color_order((GREEN, YELLOW, RED, BLUE, PURPLE)) def set_color_order(self, order): self.needles.clear() self.needles = {order[0]: cv.imread("crop/green.jpg", cv.IMREAD_COLOR), order[1]: cv.imread("crop/yellow.jpg", cv.IMREAD_COLOR), order[2]: cv.imread("crop/red.jpg", cv.IMREAD_COLOR), order[3]: cv.imread("crop/blue.jpg", cv.IMREAD_COLOR), order[4]: cv.imread("crop/purple.jpg", cv.IMREAD_COLOR), RAINBOW: cv.imread("crop/rainbow.jpg", cv.IMREAD_COLOR), BIGBOMB: cv.imread("crop/bigbomb.jpg", cv.IMREAD_COLOR), BOMB: cv.imread("crop/bomb.jpg", cv.IMREAD_COLOR), ARROW_DOWN: cv.imread("crop/arrow_down.jpg", cv.IMREAD_COLOR), ARROW_RIGHT: cv.imread("crop/arrow_right.jpg", cv.IMREAD_COLOR), MAGINENT: cv.imread("crop/maginent.jpg", cv.IMREAD_COLOR), CHEMTRANT: cv.imread("crop/chemtrant.jpg", cv.IMREAD_COLOR), TENESENT: cv.imread("crop/tenesent.jpg", cv.IMREAD_COLOR), CIBUTRANT: cv.imread("crop/cibutrant.jpg", cv.IMREAD_COLOR), ARTISENT: cv.imread("crop/artisent.jpg", cv.IMREAD_COLOR) } self.hsh_needles.clear() self.hsh_needles = {order[0]: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), order[1]: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), order[2]: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), order[3]: HsvFilter(60, 40, 0, 115, 255, 255, 0, 0, 0, 0), order[4]: HsvFilter(120, 45, 0, 170, 255, 255, 0, 0, 0, 0), RAINBOW: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), BIGBOMB: HsvFilter(60, 40, 0, 179, 129, 129, 0, 0, 0, 0), BOMB: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), ARROW_DOWN: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), ARROW_RIGHT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), MAGINENT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), CHEMTRANT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), TENESENT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), CIBUTRANT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0), ARTISENT: HsvFilter(0, 0, 0, 179, 255, 255, 0, 0, 0, 0) } def assess_playfield_and_make_move(self): new_observation, new_screenshot = self.get_current_board_state() # wrong movement detection # last board state is same as actual if mse(new_observation, self.observation) == 0.0: # no movement detected -> blow explosives or reset self.reset_counter += 1 if self.reset_counter == 1: pass elif self.reset_counter == 2: if self.detonate_explosive_when_stuck(new_observation): new_observation, new_screenshot = self.get_current_board_state() if mse(new_observation, self.observation) != 0.0: self.reset_counter = 0 return elif self.reset_counter >= 3: screenshot = self.capture_window.get_screenshot() if self.check_for_button_and_execute(screenshot, self.reset_board): cv.waitKey(500) screenshot = self.capture_window.get_screenshot() if self.check_for_button_and_execute(screenshot, self.reset_confirm): cv.waitKey(500) color_list = [PURPLE, BLUE, RED, YELLOW, GREEN] random.shuffle(color_list) self.set_color_order(color_list) self.current_strategy = random.choice([RAINBOW_STRATEGY, BIGBOMB_STRATEGY, ROCKET_STRATEGY, BOMB_STRATEGY]) self.reset_counter = 0 return else: return self.find_patterns_and_valid_moves(new_observation) self.observation = new_observation return new_observation def get_current_board_state(self): # get an updated image of the game screenshot = self.capture_window.get_screenshot() # screenshot = cv.imread("playfield.jpg") screenshot = screenshot[190:1230, 260:2090] self.screenshot = screenshot # gray = cv.cvtColor(screenshot, cv.COLOR_BGR2GRAY) # thresh = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1] offset_left = 230 offset_down = 58 if self.check_for_button_and_execute(screenshot, self.next_level, offset_left, offset_down): self.set_color_order((GREEN, YELLOW, RED, BLUE, PURPLE)) self.current_strategy = RAINBOW_STRATEGY cv.waitKey(500) screenshot = self.capture_window.get_screenshot() screenshot = screenshot[190:1230, 260:2090] if self.check_for_button_and_execute(screenshot, self.next_level_x, offset_left, offset_down): cv.waitKey(500) screenshot = self.capture_window.get_screenshot() screenshot = screenshot[190:1230, 260:2090] # cv.imshow("screenshot", screenshot) # cv.waitKey(150) # continue data_coords = np.zeros((8, 14), dtype=object) # field = Pickaxe_Field() for needle_key in self.needles.keys(): # gray_needle = cv.cvtColor(self.needles[needle_key], cv.COLOR_BGR2GRAY) # thresh_needle = cv.threshold(gray_needle, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU)[1] processed_screenshot = self.vision_stun.apply_hsv_filter(screenshot, self.hsh_needles[needle_key]) processed_needle = self.vision_stun.apply_hsv_filter(self.needles[needle_key], self.hsh_needles[needle_key]) rectangles = self.vision_stun.find(processed_screenshot, processed_needle, 0.70, 56) # rectangles = self.vision_stun.find(screenshot, self.needles[needle_key], 0.70, 56) if len(rectangles) == 0: continue points = self.vision_stun.get_click_points(rectangles) for point in points: x, y = self.point_in_rect(point) if x is not None and y is not None: data_coords[x][y] = int(needle_key) # self.change_value(x, y, int(needle_key)) # print(field.data_value_grid) # cv.circle(screenshot, points[0], 7, (0, 255, 0), -1) # output_image = vision_stun.draw_rectangles(screenshot, rectangles) # cv.imshow("output_image", output_image) # cv.waitKey(150) score_map = np.zeros((8, 14), dtype=object) for x in range(0, 8, 1): for y in range(0, 14, 1): score_map[x, y] = self.score_for_attached_same_color_all_directions(data_coords, x, y) #cv.putText(screenshot, str(score_map[x, y]), # self.get_click_point(self.data_coordinates[x, y]), cv.FONT_HERSHEY_SIMPLEX, # 1, (0, 0, 0), 3, 2) #cv.imwrite('screenshot_scored.jpg', screenshot) return data_coords, screenshot def find_patterns_and_valid_moves(self, state): # score_map = np.zeros((8, 14), dtype=object) for x in range(0, 8, 1): for y in range(0, 14, 1): self.data_score_map[x, y] = self.score_for_attached_same_color_all_directions(state, x, y) if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': return if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': return full_moves = [] reserve_moves = [] for x in range(0, 8, 1): for y in range(0, 14, 1): if self.check_explosives(state, x, y): return if self.data_score_map[x, y] >= 4: path_option = [[x, y]] recursion_reminder = [[x, y]] result = self.find_next_same_color_all_directions_recursion(state, x, y, path_option, recursion_reminder, True) if result == STATUS_FOUND_ENDING: path_option.append([x, y]) if len(path_option) >= 5: full_moves.append((state[x, y], path_option)) if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': return if self.data_score_map[x, y] >= 1: path_option = [[x, y]] self.find_next_same_color_all_directions_recursion2(state, x, y, path_option) if len(path_option) >= 3: reserve_moves.append((state[x, y], path_option)) if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': return if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': return if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': return # print(self.data_score_map) # screenshot = cv.imread("screenshot_scored.jpg") full_dic = self.convert_moves_to_dic_by_color(full_moves) res_dic = self.convert_moves_to_dic_by_color(reserve_moves) full_moves.sort(key=len, reverse=True) reserve_moves.sort(key=len, reverse=True) if len(full_dic) >= 1: for key in sorted(full_dic): if len(full_dic[key]) >= self.current_strategy: #self.print_move(full_dic[key]) self.execute_move(full_dic[key]) return if len(reserve_moves) >= 1: for key in sorted(res_dic): #self.print_move(res_dic[key]) self.execute_move(res_dic[key]) break @staticmethod def convert_moves_to_dic_by_color(reserve_moves): dic = {} for color, move in reserve_moves: if color in dic: if len(move) > len(dic[color]): dic[color] = move else: dic[color] = move return dic def print_move(self, move): mp = [] for point in move: cp = self.get_click_point(self.data_coordinates[point[0], point[1]]) mp.append(cp) cv.polylines(self.screenshot, [np.array(mp)], isClosed=False, color=(0, 255, 0), thickness=3) cv.imwrite('screenshot_pathed.jpg', self.screenshot) def execute_move(self, move): offset_left = 230 offset_down = 58 first = True for cords in move: square = self.data_coordinates[cords[0], cords[1]] pydirectinput.moveTo(get_click_point(square)[0] + offset_left, get_click_point(square)[1] + offset_down) cv.waitKey(50) if first: pydirectinput.mouseDown() cv.waitKey(100) first = False pydirectinput.mouseUp() cv.waitKey(50) @staticmethod def get_directions_array(current_x, current_y): left_x = current_x left_y = current_y - 1 right_x = current_x right_y = current_y + 1 upper_x = current_x - 1 upper_y = current_y lower_x = current_x + 1 lower_y = current_y lower_left_x = current_x + 1 lower_left_y = current_y - 1 lower_right_x = current_x + 1 lower_right_y = current_y + 1 upper_left_x = current_x - 1 upper_left_y = current_y - 1 upper_right_x = current_x - 1 upper_right_y = current_y + 1 directions = [[left_x, left_y], [lower_left_x, lower_left_y], [lower_x, lower_y], [lower_right_x, lower_right_y], [right_x, right_y], [upper_right_x, upper_right_y], [upper_x, upper_y], [upper_left_x, upper_left_y]] return directions def find_next_same_color_all_directions_recursion(self, state, current_x, current_y, path_store, recursion_reminder, look_for_ending): directions = self.get_directions_array(current_x, current_y) color = state[current_x, current_y] for direction in directions: if self.is_direction_in_bounce_and_same_color(state, direction, color) == 1: if (self.data_score_map[direction[0], direction[1]] >= 2) and (direction not in recursion_reminder): recursion_reminder.append(direction) result = self.find_next_same_color_all_directions_recursion(state, direction[0], direction[1], path_store, recursion_reminder, look_for_ending) if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': break if result == STATUS_FOUND_CONTINUATION: path_store.append(direction) return STATUS_FOUND_CONTINUATION elif result == STATUS_FOUND_DEADEND: if look_for_ending: continue else: path_store.append(direction) return STATUS_FOUND_DEADEND elif result == STATUS_FOUND_ENDING: path_store.append(direction) return STATUS_FOUND_ENDING if look_for_ending: for direction in directions: if direction == path_store[0]: # path_store.append(direction) return STATUS_FOUND_ENDING return STATUS_FOUND_DEADEND def find_next_same_color_all_directions_recursion2(self, state, current_x, current_y, path_store): directions = self.get_directions_array(current_x, current_y) color = state[current_x, current_y] for direction in directions: if self.is_direction_in_bounce_and_same_color(state, direction, color) == 1: if (self.data_score_map[direction[0], direction[1]] >= 1) and (direction not in path_store): path_store.append(direction) result = self.find_next_same_color_all_directions_recursion2(state, direction[0], direction[1], path_store) if self.overlay.run_mode == 'stopped' or self.overlay.run_mode == 'paused': break if result == STATUS_FOUND_DEADEND: return STATUS_FOUND_DEADEND return STATUS_FOUND_DEADEND def score_for_attached_same_color_all_directions(self, state, current_x, current_y): directions = self.get_directions_array(current_x, current_y) score = 0 color = state[current_x, current_y] if color not in self.colors: return score for direction in directions: score = score + self.is_direction_in_bounce_and_same_color(state, direction, color) return score