Initial Commit

Author: Eng-M-Abdrabbou

Game_Automation.py

@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*-
+
+import pyautogui
+import pytesseract
+from PIL import Image, ImageGrab, ImageOps, ImageChops
+import time
+import random
+import re
+import imagehash  # for checking if images look different
+import math 
+import traceback  
+import os  
+
+# --- user needs to set these stuff ---
+# path to tesseract exe, pls set this
+try:
+    pytesseract.get_tesseract_version()
+    print("tesseract found yay")
+except pytesseract.TesseractNotFoundError:
+    tesseract_path = r''  # <-- pls put ur full path here!!
+    if not tesseract_path: print("\noops no tesseract path..."); exit()
+    try:
+        pytesseract.pytesseract.tesseract_cmd = tesseract_path
+        pytesseract.get_tesseract_version()
+        print(f"manual tesseract set to: {tesseract_path}")
+    except Exception as e: print(f"\nerror with tesseract path prob: {tesseract_path}"); exit()
+except Exception as e: print(f"something broke checking tesseract: {e}"); exit()
+
+# screen areas to watch (left, top, width, height)
+QUESTION_REGION = (880, 260, 300, 100)  # where question shows up
+OPTIONS_REGIONS = [  # areas for answer choices
+    (900, 370, 200, 50), 
+    (900, 440, 200, 50),
+    (900, 520, 200, 50),
+    (900, 600, 200, 50),
+]
+BACK_TO_GAME_REGION = (900, 700, 200, 50)  # popup close button area
+
+# behavior settings
+MIN_DELAY_BEFORE_ACTION = 0.8; MAX_DELAY_BEFORE_ACTION = 2.5  # random wait before doing stuff
+MIN_MOUSE_MOVE_DURATION = 0.2; MAX_MOUSE_MOVE_DURATION = 0.8  # how fast mouse moves
+ERROR_RATE = 0  # chance to click wrong answer lol
+MAX_ITERATIONS = 100000  # how many questions to try
+RETRY_LIMIT = 5  # how many times to retry if stuck
+ANIMATION_DELAY = 1.0  # wait for screen to update
+
+# ocr settings
+OCR_CONFIG = '--psm 6 --oem 1 -c tessedit_char_whitelist=0123456789xX*'  # for questions
+OCR_CONFIG_OPTIONS = '--psm 7 --oem 1 -c tessedit_char_whitelist=-0123456789.'  # for answers
+OCR_CONFIG_POPUP = '--psm 7 --oem 1'  # for popups
+POPUP_KEYWORDS = ["back", "game", "continue", "congrats"]  # words to look for in popups
+
+# debug stuff
+SAVE_DEBUG_IMAGES = False  # set true to save processed images
+DEBUG_IMAGE_DIR = "ocr_debug_images"  # where to dump images
+PREPROCESSING_THRESHOLD = 180  # image processing level
+
+# some globals to track stuff
+last_click_target_region = None
+last_question_raw_text = None
+
+def capture_screen_region(region, iteration_num=-1, region_name="unknown", save_debug=SAVE_DEBUG_IMAGES):
+    """grabs screen area and processes it for ocr"""
+    try:
+        left, top, width, height = region
+        if width <= 0 or height <= 0:
+            print(f"weird region size for {region_name}, skipping")
+            return None
+        # take screenshot and make it bw
+        screenshot = pyautogui.screenshot(region=region)
+        img_processed = ImageOps.grayscale(screenshot)
+        img_processed = img_processed.point(lambda p: 0 if p < PREPROCESSING_THRESHOLD else 255)
+        img_processed = img_processed.convert('1')
+
+        # save debug img if needed
+        if save_debug and iteration_num != -1:
+            if not os.path.exists(DEBUG_IMAGE_DIR):
+                try: os.makedirs(DEBUG_IMAGE_DIR)
+                except OSError as e: print(f"oops cant make debug dir: {e}")
+            try:
+                filename = os.path.join(DEBUG_IMAGE_DIR, f"iter_{iteration_num}_{region_name}.png")
+                img_processed.save(filename)
+            except Exception as save_err:
+                print(f"couldnt save debug img: {save_err}")
+
+        return img_processed
+    except Exception as e:
+        print(f"failed to capture {region_name}: {e}")
+        return None
+
+def ocr_image(image, config=OCR_CONFIG):
+    """reads text from image using tesseract"""
+    if image is None: return ""
+    try:
+        return pytesseract.image_to_string(image, config=config).strip()
+    except Exception as e:
+        print(f"ocr error lol: {e}")
+        return ""
+
+def clean_text_multiply(text):
+    """tidies up multiplication questions"""
+    if not text: return None
+    text = text.lower().replace(' ','').replace('x', '*')
+    cleaned = re.sub(r'[^\d\*]', '', text)
+    if not re.fullmatch(r'\d+\*\d+', cleaned):
+        return None
+    return cleaned
+
+def parse_and_solve_multiply(question_text_raw):
+    """solves simple multiplication questions"""
+    cleaned = clean_text_multiply(question_text_raw)
+    if not cleaned: return None
+    
+    match = re.match(r'^(\d+)\*(\d+)$', cleaned)
+    if not match: return None
+    
+    try:
+        num1, num2 = map(int, match.groups())
+        return num1 * num2
+    except:
+        return None
+
+def clean_text_option(text):
+    """cleans answer options text"""
+    if not text: return None
+    cleaned = re.sub(r'[^\-\d\.]', '', text)
+    if not cleaned or cleaned in ['.', '-']: return None
+    if cleaned.count('.') > 1:
+        cleaned = cleaned[:cleaned.find('.')+1] + cleaned[cleaned.find('.')+1:].replace('.', '')
+    if not re.fullmatch(r'-?\d+(\.\d+)?', cleaned):
+        return None
+    return cleaned
+
+def get_random_point_in_region(region):
+    """picks random spot in given area"""
+    left, top, width, height = region
+    return (
+        random.randint(left, left + width - 1),
+        random.randint(top, top + height - 1)
+    )
+
+def human_like_move_and_click(target_region, move_duration):
+    """moves mouse and clicks like a human-ish"""
+    global last_click_target_region
+    try:
+        x, y = get_random_point_in_region(target_region)
+        pyautogui.moveTo(x, y, duration=move_duration, 
+                        tween=random.choice([pyautogui.easeInQuad, pyautogui.easeOutQuad]))
+        time.sleep(random.uniform(0.05, 0.15))
+        pyautogui.click()
+        last_click_target_region = target_region
+    except Exception as e:
+        print(f"whoops click error: {e}")
+
+def compare_images(img1, img2):
+    """checks if two images are different using hashing"""
+    if img1 is None or img2 is None: return 999
+    try:
+        return imagehash.average_hash(img1) - imagehash.average_hash(img2)
+    except Exception as e:
+        print(f"cant compare images: {e}")
+        return 999
+
+def main():
+    global last_click_target_region, last_question_raw_text
+    print("starting...")
+    print("make sure game window is visible!")
+    for i in range(3, 0, -1):
+        print(f"starting in {i}...")
+        time.sleep(1)
+
+    last_question_image = None
+    retries = 0
+    iterations = 0
+
+    try:
+        while iterations < MAX_ITERATIONS:
+            current_iter = iterations + 1
+            print(f"\n--- loop #{current_iter} ---")
+
+            if iterations > 0:
+                time.sleep(ANIMATION_DELAY)
+
+            # grab question area
+            question_img = capture_screen_region(QUESTION_REGION, current_iter, "q")
+            if not question_img:
+                print("no question img, waiting...")
+                time.sleep(3)
+                continue
+
+            # read question text
+            question_text = ocr_image(question_img, OCR_CONFIG)
+            print(f"ocr got: '{question_text}'")
+
+            # check if screen changed
+            img_diff = compare_images(last_question_image, question_img)
+            text_diff = question_text != last_question_raw_text if last_question_raw_text else True
+            changed = img_diff >= 5 or text_diff
+
+            if not changed and last_question_image:
+                retries += 1
+                if retries > RETRY_LIMIT:
+                    print("prob stuck, checking for popup...")
+                    for _ in range(10):
+                        popup_img = capture_screen_region(BACK_TO_GAME_REGION, -1, "popup", False)
+                        popup_text = ocr_image(popup_img, OCR_CONFIG_POPUP).lower()
+                        if any(kw in popup_text for kw in POPUP_KEYWORDS):
+                            print("found popup, clicking...")
+                            human_like_move_and_click(BACK_TO_GAME_REGION, 0.3)
+                            time.sleep(1.5)
+                            break
+                        time.sleep(0.5)
+                    else:
+                        print("no popup found, exiting")
+                        break
+                    retries = 0
+                    continue
+                else:
+                    print(f"screen same, retry #{retries}")
+                    if last_click_target_region:
+                        human_like_move_and_click(last_click_target_region, 0.3)
+                    time.sleep(1)
+                    continue
+            else:
+                retries = 0
+                last_question_image = question_img
+                last_question_raw_text = question_text
+
+            # solve question
+            answer = parse_and_solve_multiply(question_text)
+            if not answer:
+                print("cant solve, clicking first option")
+                if OPTIONS_REGIONS:
+                    human_like_move_and_click(OPTIONS_REGIONS[0], 0.5)
+                iterations += 1
+                time.sleep(2)
+                continue
+
+            # read answer options
+            options = []
+            print("checking options...")
+            for idx, region in enumerate(OPTIONS_REGIONS):
+                opt_img = capture_screen_region(region, current_iter, f"opt{idx+1}")
+                opt_text = clean_text_option(ocr_image(opt_img, OCR_CONFIG_OPTIONS))
+                print(f"opt {idx+1}: {opt_text}")
+                if opt_text: options.append({"text": opt_text, "region": region})
+
+            # find matching answer
+            target = None
+            try:
+                target_num = float(answer)
+                closest = None
+                min_diff = float('inf')
+                for opt in options:
+                    try:
+                        opt_num = float(opt['text'])
+                        diff = abs(opt_num - target_num)
+                        if diff < 0.001:
+                            target = opt['region']
+                            break
+                        if diff < min_diff:
+                            closest = opt['region']
+                            min_diff = diff
+                    except: pass
+                if not target and closest and min_diff < 0.1:
+                    target = closest
+            except: pass
+
+            # decide where to click
+            if not target:
+                print("no good option, clicking first")
+                target = OPTIONS_REGIONS[0]
+            elif random.random() < ERROR_RATE:
+                print("intentional wrong click!")
+                wrongs = [r for r in OPTIONS_REGIONS if r != target]
+                if wrongs: target = random.choice(wrongs)
+
+            # do the click
+            if target:
+                human_like_move_and_click(target, random.uniform(0.2, 0.8))
+                time.sleep(random.uniform(2, 3))
+
+            iterations += 1
+
+    except KeyboardInterrupt:
+        print("\nstopped by user")
+    except Exception as e:
+        print(f"\nerror: {e}")
+        traceback.print_exc()
+    finally:
+        print(f"\ndone, did {iterations} questions")
+
+if __name__ == "__main__":
+    main()