mirror of
https://github.com/fishyboteso/fishyboteso.git
synced 2024-08-30 18:32:13 +00:00
330 lines
9.7 KiB
Python
330 lines
9.7 KiB
Python
import math
|
|
import os
|
|
import tempfile
|
|
import uuid
|
|
from zipfile import ZipFile
|
|
|
|
import cv2
|
|
import logging
|
|
import time
|
|
|
|
import numpy as np
|
|
import pytesseract
|
|
from fishy.engine.semifisher.fishing_mode import FishingMode
|
|
|
|
from fishy.engine import SemiFisherEngine
|
|
from fishy.engine.common.window import WindowClient
|
|
from fishy.engine.semifisher import fishing_mode, fishing_event
|
|
|
|
from fishy.engine.common.IEngine import IEngine
|
|
from pynput import keyboard, mouse
|
|
|
|
from fishy.helper import hotkey, helper
|
|
from fishy.helper.config import config
|
|
from fishy.helper.downloader import download_file_from_google_drive
|
|
from fishy.helper.hotkey import Key
|
|
|
|
mse = mouse.Controller()
|
|
kb = keyboard.Controller()
|
|
offset = 0
|
|
|
|
|
|
def downlaoad_and_extract_tesseract():
|
|
logging.info("Tesseract-OCR downlaoding, Please wait...")
|
|
|
|
f = tempfile.NamedTemporaryFile(delete=False)
|
|
download_file_from_google_drive("16llzcBlaCsG9fm-rY2dD4Gvopnhm3XoE", f)
|
|
f.close()
|
|
|
|
logging.info("Tesseract-OCR downloaded, now installing")
|
|
|
|
addon_dir = os.path.join(os.environ["APPDATA"], "Tesseract-OCR")
|
|
with ZipFile(f.name, 'r') as z:
|
|
z.extractall(path=addon_dir)
|
|
|
|
logging.info("Tesseract-OCR installed")
|
|
|
|
|
|
def is_tesseract_installed():
|
|
return os.path.exists(os.path.join(os.environ["APPDATA"], "Tesseract-OCR"))
|
|
|
|
|
|
def sign(x):
|
|
return -1 if x < 0 else 1
|
|
|
|
|
|
def get_crop_coods(window):
|
|
img = window.get_capture()
|
|
img = cv2.inRange(img, 0, 1)
|
|
|
|
cnt, h = cv2.findContours(img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
|
|
|
|
"""
|
|
code from https://stackoverflow.com/a/45770227/4512396
|
|
"""
|
|
for i in range(len(cnt)):
|
|
area = cv2.contourArea(cnt[i])
|
|
if 5000 < area < 100000:
|
|
mask = np.zeros_like(img)
|
|
cv2.drawContours(mask, cnt, i, 255, -1)
|
|
x, y, w, h = cv2.boundingRect(cnt[i])
|
|
return x, y + offset, x + w, y + h - offset
|
|
|
|
|
|
def image_pre_process(img):
|
|
scale_percent = 200 # percent of original size
|
|
width = int(img.shape[1] * scale_percent / 100)
|
|
height = int(img.shape[0] * scale_percent / 100)
|
|
dim = (width, height)
|
|
img = cv2.resize(img, dim, interpolation=cv2.INTER_AREA)
|
|
img = cv2.bitwise_not(img)
|
|
return img
|
|
|
|
|
|
# noinspection PyBroadException
|
|
def get_values_from_image(img, tesseract_dir):
|
|
try:
|
|
pytesseract.pytesseract.tesseract_cmd = tesseract_dir + '/tesseract.exe'
|
|
tessdata_dir_config = f'--tessdata-dir "{tesseract_dir}" -c tessedit_char_whitelist=0123456789.'
|
|
|
|
text = pytesseract.image_to_string(img, lang="eng", config=tessdata_dir_config)
|
|
text = text.replace(" ", "")
|
|
vals = text.split(":")
|
|
return float(vals[0]), float(vals[1]), float(vals[2])
|
|
except Exception:
|
|
logging.error("Couldn't read coods")
|
|
cv2.imwrite(f"fail_{str(uuid.uuid4())[:8]}", img)
|
|
return None
|
|
|
|
|
|
class FullAuto(IEngine):
|
|
rotate_by = 30
|
|
|
|
def __init__(self, gui_ref):
|
|
super().__init__(gui_ref)
|
|
self.factors = config.get("full_auto_factors", None)
|
|
self._tesseract_dir = None
|
|
self._target = None
|
|
self.crop = config.get("full_auto_crop")
|
|
|
|
if self.factors is None:
|
|
logging.warning("Please callibrate first")
|
|
|
|
self._hole_found_flag = False
|
|
self._curr_rotate_y = 0
|
|
|
|
self.fisher = SemiFisherEngine(None)
|
|
self.controls = Controls(self.get_controls())
|
|
|
|
@property
|
|
def show(self):
|
|
return config.get("show_window_full_auto", False)
|
|
|
|
@show.setter
|
|
def show(self, x):
|
|
config.set("show_window_full_auto", x)
|
|
|
|
def update_crop(self):
|
|
self.show = True
|
|
self.crop = get_crop_coods(self.window)
|
|
config.set("full_auto_crop", self.crop)
|
|
self.window.crop = self.crop
|
|
|
|
def run(self):
|
|
logging.info("Loading please wait...")
|
|
self.gui.bot_started(True)
|
|
fishing_event.unsubscribe()
|
|
self.fisher.toggle_start()
|
|
|
|
self.window = WindowClient(color=cv2.COLOR_RGB2GRAY, show_name="Full auto debug")
|
|
if self.crop is None:
|
|
self.update_crop()
|
|
self.window.crop = self.crop
|
|
|
|
self._tesseract_dir = os.path.join(os.environ["APPDATA"], "Tesseract-OCR")
|
|
if not is_tesseract_installed():
|
|
logging.info("tesseract not found")
|
|
downlaoad_and_extract_tesseract()
|
|
|
|
self.controls.change_state()
|
|
while self.start and WindowClient.running():
|
|
self.window.show(self.show, func=image_pre_process)
|
|
if not self.show:
|
|
time.sleep(0.1)
|
|
|
|
self.gui.bot_started(False)
|
|
self.controls.unassign_keys()
|
|
self.window.show(False)
|
|
logging.info("Quit")
|
|
self.window.destory()
|
|
self.fisher.toggle_start()
|
|
|
|
def get_coods(self):
|
|
return get_values_from_image(self.window.processed_image(func=image_pre_process), self._tesseract_dir)
|
|
|
|
def move_to(self, target):
|
|
if target is None:
|
|
logging.error("set target first")
|
|
return
|
|
|
|
if self.factors is None:
|
|
logging.error("you need to callibrate first")
|
|
return
|
|
|
|
current = self.get_coods()
|
|
print(f"Moving from {(current[0], current[1])} to {target}")
|
|
move_vec = target[0] - current[0], target[1] - current[1]
|
|
|
|
dist = math.sqrt(move_vec[0] ** 2 + move_vec[1] ** 2)
|
|
print(f"distance: {dist}")
|
|
if dist < 5e-05:
|
|
print("distance very small skipping")
|
|
return
|
|
|
|
target_angle = math.degrees(math.atan2(-move_vec[1], move_vec[0])) + 90
|
|
from_angle = current[2]
|
|
|
|
self.rotate_to(target_angle, from_angle)
|
|
|
|
walking_time = dist / self.factors[0]
|
|
print(f"walking for {walking_time}")
|
|
kb.press('w')
|
|
time.sleep(walking_time)
|
|
kb.release('w')
|
|
print("done")
|
|
|
|
def rotate_to(self, target_angle, from_angle=None):
|
|
if from_angle is None:
|
|
_, _, from_angle = self.get_coods()
|
|
|
|
if target_angle < 0:
|
|
target_angle = 360 + target_angle
|
|
while target_angle > 360:
|
|
target_angle -= 360
|
|
print(f"Rotating from {from_angle} to {target_angle}")
|
|
|
|
angle_diff = target_angle - from_angle
|
|
|
|
if abs(angle_diff) > 180:
|
|
angle_diff = (360 - abs(angle_diff)) * sign(angle_diff) * -1
|
|
|
|
rotate_times = int(angle_diff / self.factors[1]) * -1
|
|
|
|
print(f"rotate_times: {rotate_times}")
|
|
|
|
for _ in range(abs(rotate_times)):
|
|
mse.move(sign(rotate_times) * FullAuto.rotate_by * -1, 0)
|
|
time.sleep(0.05)
|
|
|
|
def look_for_hole(self):
|
|
self._hole_found_flag = False
|
|
|
|
if FishingMode.CurrentMode == fishing_mode.State.LOOK:
|
|
return True
|
|
|
|
def found_hole(e):
|
|
if e == fishing_mode.State.LOOK:
|
|
self._hole_found_flag = True
|
|
|
|
fishing_mode.subscribers.append(found_hole)
|
|
|
|
t = 0
|
|
while not self._hole_found_flag and t <= self.factors[2] / 3:
|
|
mse.move(0, FullAuto.rotate_by)
|
|
time.sleep(0.05)
|
|
t += 0.05
|
|
while not self._hole_found_flag and t > 0:
|
|
mse.move(0, -FullAuto.rotate_by)
|
|
time.sleep(0.05)
|
|
t -= 0.05
|
|
|
|
self._curr_rotate_y = t
|
|
fishing_mode.subscribers.remove(found_hole)
|
|
return self._hole_found_flag
|
|
|
|
def rotate_back(self):
|
|
while self._curr_rotate_y > 0.01:
|
|
mse.move(0, -FullAuto.rotate_by)
|
|
time.sleep(0.05)
|
|
self._curr_rotate_y -= 0.05
|
|
|
|
def get_controls(self):
|
|
from fishy.engine.fullautofisher.calibrate import Calibrate
|
|
from fishy.engine.fullautofisher.recorder import Recorder
|
|
from fishy.engine.fullautofisher.player import Player
|
|
|
|
def change_state():
|
|
self.controls.change_state()
|
|
|
|
def print_coods():
|
|
logging.info(self.get_coods())
|
|
|
|
def set_target():
|
|
t = self.get_coods()[:-1]
|
|
config.set("target", t)
|
|
print(f"target_coods are {t}")
|
|
|
|
def move_to_target():
|
|
self.move_to(config.get("target"))
|
|
|
|
def rotate_to_90():
|
|
self.rotate_to(90)
|
|
|
|
def toggle_show():
|
|
self.show = not self.show
|
|
|
|
controls = [
|
|
("MAIN", {
|
|
Key.RIGHT: Player(self).start_route,
|
|
Key.UP: Calibrate(self).callibrate,
|
|
Key.LEFT: Recorder(self).start_recording,
|
|
Key.DOWN: change_state
|
|
}),
|
|
("COODS", {
|
|
Key.RIGHT: print_coods,
|
|
Key.UP: self.update_crop,
|
|
Key.LEFT: toggle_show,
|
|
Key.DOWN: change_state
|
|
}),
|
|
("TEST1", {
|
|
Key.RIGHT: set_target,
|
|
Key.UP: rotate_to_90,
|
|
Key.LEFT: move_to_target,
|
|
Key.DOWN: change_state
|
|
})
|
|
]
|
|
|
|
return controls
|
|
|
|
|
|
class Controls:
|
|
def __init__(self, controls, first=0):
|
|
self.current_menu = first - 1
|
|
self.controls = controls
|
|
|
|
def change_state(self):
|
|
self.current_menu += 1
|
|
if self.current_menu == len(self.controls):
|
|
self.current_menu = 0
|
|
|
|
help_str = F"CONTROLS: {self.controls[self.current_menu][0]}"
|
|
for key, func in self.controls[self.current_menu][1].items():
|
|
hotkey.set_hotkey(key, func)
|
|
help_str += f"\n{key.value}: {func.__name__}"
|
|
logging.info(help_str)
|
|
|
|
def unassign_keys(self):
|
|
keys = []
|
|
for c in self.controls:
|
|
for k in c[1].keys():
|
|
if k not in keys:
|
|
hotkey.free_key(k)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
logging.getLogger("").setLevel(logging.DEBUG)
|
|
hotkey.initalize()
|
|
# noinspection PyTypeChecker
|
|
bot = FullAuto(None)
|
|
bot.toggle_start()
|