minecraft_fishing_bot.py

# TODO: check Minecraft settings. [Esc -> Options... -> Controls... -> Mouse Settings... -> Raw input: OFF]
# TODO: make get_window_handles(winName) function more spesific (other windows with "Minecraft" in their name can trigger this function)
# TODO: try-catch for rtesseract.exe if not found
# TODO: add a way to stop the bot instead of CTRL + C
# TODO: possible code duplication with x, y, h, w variables and window_dimensions[] in 'def capture_window(window_handle):' function
#       maybe make a function that returns the x, y, h, w variables, but will lose the real time windows resizing functionality
# Done: generate updated requirements.txt file
# Last Run: 02-03-2025 python 3.12

import os
import re
import sys
import cv2
import time
import datetime
import pytesseract
import numpy
import win32con
import win32gui
import win32ui
from pynput.mouse import Button, Controller as MouseController
from pynput.keyboard import Key, KeyCode, Controller as KeyboardController
from PIL import Image
from shutil import copyfile

phrase = "bobber splashes"
pytesseract.pytesseract.tesseract_cmd = "C:\\Program Files\\Tesseract-OCR\\tesseract.exe"
regex_pattern = r"\[System\] \[CHAT\].*?(?<![\w-])[a-z]*?(rex[y]?|-> me\])"
log_file_path = os.path.join(os.getenv('APPDATA'), ".minecraft", "logs", "latest.log")
log_file_copy_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "latest_copy.log")
previous_timestamp = None
flag_fillExpPotions = True
flag_Eat = False

mouse_controller = MouseController()
keyboard_controller = KeyboardController()

start_t = datetime.datetime.now().time()
start_td = datetime.timedelta(hours=start_t.hour, minutes=start_t.minute, seconds=start_t.second)
end_t = None
end_td = None

# hotbar dictionary for key switchinch in Minecraft, the values are the number of items in the slot, or a keyword for the item
# the slot 3 to 9 filled with a full stack - 1 becuase we need to reserve inventory space for the exp bottles. without it the inventory
# will be filled with fishing drops
hotbar = {
    "1": 64,       # food slot
    "2": "Rod",    # tool slot
    "3": 128,        # empty exp potion slot
    "4": 128,        # empty exp potion slot
    "5": 128,        # empty exp potion slot
    "6": 128,        # empty exp potion slot
    "7": 128,        # empty exp potion slot
    "8": 128,        # empty exp potion slot
    "9": 128         # empty exp potion slot
}

# getting all the windows handles with the name "Minecraft" at the start into a list ::should be only ONE in the list!::
def get_window_handles(winName):
    def callback(handle, extra):
        if win32gui.IsWindowVisible(handle) and win32gui.GetWindowText(handle)[0:9] == winName:
            window_handles.append(handle)
    window_handles = []
    win32gui.EnumWindows(callback, None)
    return window_handles

def capture_window(window_handle):
    if window_handle is None:
        window_handle = win32gui.GetDesktopWindow()
    # getting Minecraft window dimensions into 4 variables for convenience of use
    window_dimensions = win32gui.GetWindowRect(window_handle)
    left = window_dimensions[0]
    top = window_dimensions[1]
    right = window_dimensions[2]
    bottom = window_dimensions[3]
    # setting the borders for the capture area (buttom-left side of the Minecraft window)
    left_border = 8
    right_border = 8
    top_border = 30
    bottom_border = 8
    # calculating the capture area for cropping the screenshot
    width = right - left - left_border - right_border
    height = bottom - top - top_border - bottom_border
    cropped_x = left_border
    cropped_y = top_border
    # capturing the screenshot based on the calculated dimensions
    window_device_context = win32gui.GetWindowDC(window_handle)
    device_context_object = win32ui.CreateDCFromHandle(window_device_context)
    create_device_context = device_context_object.CreateCompatibleDC()
    # creating a bitmap object for because the screenshot is a bitmap
    data_bit_map = win32ui.CreateBitmap()
    data_bit_map.CreateCompatibleBitmap(device_context_object, width, height)
    create_device_context.SelectObject(data_bit_map)
    # BitBlt is a Windows API function that copies the contents of one device context into another
    create_device_context.BitBlt(
        (0, 0),
        (width, height),
        device_context_object,
        (cropped_x, cropped_y),
        win32con.SRCCOPY,
    )
    # instead of saving the screenshot to a file, we can just get the raw data from the bitmap object
    image = numpy.frombuffer(data_bit_map.GetBitmapBits(True), dtype="uint8")
    # the 4 is for the number of color channels (RGB + alpha), may change it to 3 if the alpha channel is not needed
    image.shape = (height, width, 4)
    # releasing the device contexts and deleting the bitmap object, if we dont do this, we will get a memory leak
    device_context_object.DeleteDC()
    create_device_context.DeleteDC()
    win32gui.ReleaseDC(window_handle, window_device_context)
    win32gui.DeleteObject(data_bit_map.GetHandle())
    return image

def type_a_command(command_string):
    keyboard_controller.press(KeyCode.from_char("/"))
    keyboard_controller.release(KeyCode.from_char("/"))
    time.sleep(0.2)
    keyboard_controller.type(command_string[1:])
    time.sleep(0.2)
    keyboard_controller.press(Key.enter)
    keyboard_controller.release(Key.enter)
    time.sleep(0.2)
    mouse_controller.click(Button.left)
    time.sleep(0.2)

def fill_exp_potions(hotbar):
    # This function is for filling the empty bottles from the SlimeFun plugin with exp
    for i in range(3, 10):
        if hotbar[str(i)] > 0: # as long as the slot in hotbar is not empty
            hotbar[str(i)] -= 1
            keyboard_controller.type(str(i))
            time.sleep(0.4)
            mouse_controller.click(Button.right)
            time.sleep(0.4)
            break  # Exit the loop after filling one bottle
    keyboard_controller.type('2') # Switch back to the fishing rod slot which is "2"
    time.sleep(0.3)
    # Return hotbar

def action_eat(hotbar):
    # this function is for eating food from the food slot in the hotbar
    # IMPORTANT: the SlimeFun plugin food is 1 click instead of holding the right mouse button
    if hotbar['1'] > 0:
        hotbar['1'] = hotbar['1'] - 1
        keyboard_controller.type('1')
        time.sleep(0.8)
        mouse_controller.click(Button.right) # eat
        time.sleep(0.8)
        keyboard_controller.type('2') # switch back to weapon slot which is "2"

def check_log_file():
    global previous_timestamp
    try:
        current_timestamp = os.path.getmtime(log_file_path)
        if current_timestamp != previous_timestamp:
            previous_timestamp = current_timestamp
            # for some reasen, the Minecraft logfile cannot be read as needed, so we copy it to a new file and read it
            copyfile(log_file_path, log_file_copy_path)
            with open(log_file_copy_path, errors='ignore', mode='r') as file:
                lines = file.readlines()
                if lines:
                    last_line = lines[-1].rstrip()
                    return last_line
                else:
                    print("Log file is empty.")
            return None
    except IOError as e:
        print('Cannot open the logfile. Error: {}'.format(e))

def main():
    global end_td  # Declare td_end as a global variable
    fishing_count = 0
    left_right = False
    # Variables for FPS calculation
    frame_count = 0
    start_time = time.time()
    fps = 0
    prev_fps_update_time = start_time
    read_count=0

    # Font settings for FPS display
    font = cv2.FONT_HERSHEY_SIMPLEX
    font_scale = 0.7
    color = (0, 255, 0)  # Green color
    thickness = 2
    position = (10, 30)  # Top-left corner of the text

    while True:
        # constant check for the Minecraft window
        if len(get_window_handles("Minecraft")) == 0:
            print("Error: no windows with the name \"Minecraft\" were found")
            break

        # constant search for keywords in Minecraft chat but only every 10 loops or 'frames'
        # after reading the log file, check if the last line contains the keyword
        if read_count % 10 == 0:
            last_line = check_log_file()
            if last_line and re.search(regex_pattern, str(last_line)):
                print("Found somting! {} and {}".format(last_line, re.search(regex_pattern, str(last_line))))
        read_count += 1

        # strat video vision proccessing
        screenshot = capture_window(get_window_handles("Minecraft")[0])
        x, y, w, h = (
            # this will limit the capture area to the buttom-left side of the Minecraft window
            screenshot.shape[1] * 3 // 4,
            screenshot.shape[0] * 3 // 4,
            screenshot.shape[1] // 4,
            screenshot.shape[0] // 4,
        )
        # screenshot now contains only the bottom-left part of the Minecraft window
        screenshot = screenshot[y : y + h, x : x + w]

        # Pytesseract OCR configs for better text recognition (all configs here: https://muthu.co/all-tesseract-ocr-options/)
        # Page segmentation modes (psm) values:
        # 0   Orientation and script detection (OSD) only.
        # 1   Automatic page segmentation with OSD.
        # 2   Automatic page segmentation, but no OSD, or OCR.
        # 3   Fully automatic page segmentation, but no OSD. (Default)
        # 4   Assume a single column of text of variable sizes.
        # 5   Assume a single uniform block of vertically aligned text.
        # 6   Assume a single uniform block of text.
        # 7   Treat the image as a single text line.
        # 8   Treat the image as a single word.
        # 9   Treat the image as a single word in a circle.
        # 10  Treat the image as a single character.
        # 11  Sparse text. Find as much text as possible in no particular order.
        # 12  Sparse text with OSD.
        # 13  Raw line. Treat the image as a single text line, bypassing hacks that are Tesseract-specific.
        # OCR Engine modes (oem) values:
        # 0   Legacy engine only.
        # 1   Neural nets LSTM engine only.
        # 2   Legacy + LSTM engines.
        # 3   Default, based on what is available.
        cfg = '--psm 7 --oem 0'
        screenshot_filter = cv2.cvtColor(screenshot, cv2.COLOR_BGR2GRAY)
        text = pytesseract.image_to_string(
            image = cv2.threshold(screenshot_filter, 220, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
        )
        # print("debug: text value is: ", text)
        if phrase in text.lower():
            end_t = datetime.datetime.now().time()
            end_td = datetime.timedelta(hours=end_t.hour, minutes=end_t.minute, seconds=end_t.second)
            print("fish on, ", end=" ")
            mouse_controller.click(Button.right)
            fishing_count += 1
            print("bobber retrieved, num: {},".format(fishing_count) , end=" ")
            time.sleep(0.4)
            if flag_fillExpPotions: #(fishing_count % 2) == 0 and | fill exp bottles every 2 fishing
                time.sleep(0.5)
                # fill_exp_potions(hotbar)
                time.sleep(0.9)
            # eat every 10 fishings
            if left_right: # rotate the camera back and forth every fishing
                mouse_controller.move(500, 0)
                left_right = False
                print("Moved to the Right")
            else:
                mouse_controller.move(-500, 0)
                left_right = True
                print("Moved to the Left")
                # executing the /balance command to track how much money you get from fishing (/jobs plugin)
                # type_a_command("/bal")
            time.sleep(0.8)
            mouse_controller.click(Button.right)
            print("bobbern thrown,", end=" ")
            time.sleep(2.5)
            # td_end = datetime.timedelta(hours=end_time.hour, minutes=end_time.minute, seconds=end_time.second)


        # converting the screenshot into grayscale and then back to BGR and finally trimming to the same color channels as the screenshot
        screenshot_filter = cv2.cvtColor(screenshot, cv2.COLOR_BGR2GRAY)
        screenshot_filter = cv2.cvtColor(screenshot_filter, cv2.COLOR_GRAY2BGR)
        screenshot = screenshot[:,:,:3]
        tess_view = cv2.threshold(cv2.cvtColor(screenshot, cv2.COLOR_BGR2GRAY), 128, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
        tess_view = cv2.cvtColor(tess_view, cv2.COLOR_GRAY2BGR)

        """
        # attempting adaptiveThreshold to see if the text readbilty from the screenshot is easier for the Tesseract
        tess_view2 = cv2.adaptiveThreshold(cv2.cvtColor(screenshot, cv2.COLOR_BGR2GRAY),255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,11,2)
        tess_view2 = cv2.cvtColor(tess_view2, cv2.COLOR_GRAY2BGR)

        # testing print for image shapes , ALL image output have to be the same size AND same color format in order to stack in numpy imshow
        print("screenshot\t", screenshot.shape)
        print("screenshot_filter\t", screenshot_filter.shape)
        print("teseract\t", tess_view.shape)
        print("teseract2\t", tess_view2.shape)
        """
        # Calculate FPS
        current_time = time.time()
        frame_count += 1

        # Update FPS approximately every second
        if current_time - prev_fps_update_time >= 1.0:
            # Calculate the FPS over the last second
            elapsed_time = current_time - prev_fps_update_time
            fps = frame_count / elapsed_time
            # Reset counters
            prev_fps_update_time = current_time
            frame_count = 0

        # Display FPS on the image
        fps_text = f"FPS: {fps:.2f}"
        screenshot_with_fps = screenshot.copy()
        cv2.putText(screenshot_with_fps, fps_text, position, font, font_scale, color, thickness, cv2.LINE_AA)
        cv2.imshow("Computer Vision - ALL", numpy.vstack((
            screenshot_with_fps
            ,screenshot_filter
            ,tess_view
            #,tess_view2
            )))

        if cv2.waitKey(1) == ord("q"):
            cv2.destroyAllWindows()
            break
        end_time = datetime.datetime.now().time()

if __name__ == "__main__":
    print("Starting fishing at: {}".format(start_t))
    try:
        main()
    except KeyboardInterrupt:
        # execute the next lines after KeyboardInterrupt: Ctrl+C is pressed to stop the script
        try:
            print("\nFished for: {} (hh:mm:ss)".format(end_td - start_td))
        except TypeError:
            print("\nTypeError (its fine)")
        try:
            sys.exit(130)
        except SystemExit:
            os._exit(130)