Platform: MacOS

Prerequisite: Basic Python

Introduction#

Today I have randomly chosen from one of my favorite iOS games and decided to write a script for it, with iPhone Mirroring. It’s called Egg Inc. A game where you raise chickens, the chickens lay eggs, and you make profits by shipping the eggs. My goal today will be writing a program specifically for Prestige.

The Main Idea#

On iPhone mirroring, mouse clicks simulate taps on the iPhone. This is great because I already know how to simulate clicks, presses, and drags. Prestige is a fairly mechanical process—it’s repeated over and over, and I have already identified a pattern in it. Essentially, this program will follow a specific pattern to perform prestige.

IMPORTANT
This is not a tutorial. I have intentionally omitted many details that are not directly related. In the future, I might write another log about them. Please do not be surprised if things don’t work after following everything in this blog. Also, please don’t have high expectations: even after optimizations, its efficiency is still terrible compared to manual prestige.

Watch the demo on

Limitations#

That being said, if you’re looking for a one-size-fits-all program, you might be out of luck, as this is highly experimental. You’ll also need at least a basic understanding of programming to follow the materials presented in this article.

On top of that, players have different prestige strategies. I will list mine here.

Start from Edible
Jump to Dilithium
Get enough farm value and jump to Universe
Get soul eggs and prestige

Sounds easy? Okay, I admit I’ve omitted a lot of details. Now, I will follow this pattern and build a program based on it.

FYI, my current Earning Bonus and Prestige set:

earning-bonus-and-prestige-set

The Program#

Step 1️⃣#

The first thing I’m going to do is open up my new toy, iPhone Mirroring.

new-farm

Next, I start a new Python project.

program-hierarchy

Step 2️⃣#

The next step is to confirm the window size and position so that it remains consistent every time I open it. It seems I can’t change the window size, which is fantastic because it means I won’t need to write a window_rescaler.py for it. I’ll simply place iPhone Mirroring in the top-left corner of my Desktop, to make sure that my clicks always occur in the expected positions.

top-left-corner

Step 3️⃣#

Let’s make some clicks. Create mouse.py under interaction.

1
import time
2
import pyautogui
3

4

5
class Mouse:
6
    def click_pos(self, pos, sleep_time=0.2, once=False):
7
        x, y = pos
8
        self.click(x, y, sleep_time, once)
9

10
    @staticmethod
11
    def click(x, y, sleep_time=0.2, once=False):
12
        pyautogui.click(x, y)
13
        if not once:
14
            pyautogui.click(x, y)
15
        time.sleep(sleep_time)
16

17
    @staticmethod
18
    def perform_drag(drag_from, drag_to, duration=0.5):
19
        start_x, start_y = drag_from[0], drag_from[1]
20
        end_x, end_y = drag_to[0], drag_to[1]
21
        pyautogui.moveTo(start_x, start_y)
22
        pyautogui.mouseDown()
23
        pyautogui.dragTo(end_x, end_y, duration=duration, button='left')
24
        pyautogui.mouseUp()
25

26
    def press_pos(self, pos, duration):
27
        x, y = pos
28
        self.click_pos(pos)
29
        self.press(x, y, duration)
30

31
    @staticmethod
32
    def press(x, y, duration):
33
        pyautogui.moveTo(x, y)
34
        pyautogui.mouseDown()
35
        time.sleep(duration)
36
        pyautogui.mouseUp()

Test the code. Here I tried to click on the ‘Send Chicken’ button.

1
if __name__ == '__main__':
2
    mouse = Mouse()
3
    mouse.click_pos([153, 665])

HOORAY
🎉 It works!

NOTE
You will need to find the position using mouse_coordinate.py, which I will be introducing in step 4.

send-chicken

NOTE
However, I soon encountered a problem. It seems that sometimes I need to tap twice on the simulator for the interaction to work, and it doesn’t appear to be an issue of focusing. This complicates things. To address this, I added a flag once to indicate whether the click should be performed only once. By default, it performs two clicks.

That’s a good start. Now let’s see drags.

1
if __name__ == '__main__':
2
    mouse = Mouse()
3

4
    drag_from = [70, 540]
5
    drag_to = [70, 380]
6
    drag_duration = 1
7
    mouse.perform_drag(drag_from, drag_to, drag_duration)

test-drag

HOORAY
🎉 Excellent, it dragged the research menu down. Now I am confident that I have everything I need to control the device.

Step 4️⃣#

In this step I will create some utility scripts.

I imagine it’s going to have massive logs so I will need a class that can generate and store the logs. Create logger.py under log.

1
import os
2
import fnmatch
3

4
script_dir = os.path.dirname(os.path.abspath(__file__))
5
logs_path = os.path.join(script_dir, 'logs')
6

7

8
class Logger:
9
    def __init__(self):
10
        self._content = []
11

12
    def add_content(self, line):
13
        self._content.append(line)
14

15
    def save_content(self):
16
        os.makedirs(logs_path, exist_ok=True)
17
        new_save_path = self.get_new_save_path()
18
        with open(new_save_path, 'w') as file:
19
            file.write("\n".join(self._content))
20

21
    @staticmethod
22
    def get_new_save_path():
23
        prefix_name = 'log'
24
        max_num = 0
25
        for dirpath, dirnames, filenames in os.walk(logs_path):
26
            for filename in fnmatch.filter(filenames, '*.txt'):
27
                num = int(filename.replace(prefix_name, '').replace('.txt', ''))
28
                if num > max_num:
29
                    max_num = num
30
        return os.path.join(logs_path, prefix_name + str(max_num + 1) + '.txt')
31

32

33
if __name__ == '__main__':
34
    logger = Logger()
35
    print(logger.get_new_save_path())
36
    logger.add_content('test')
37
    logger.add_content('test2')
38
    logger.save_content()

As expected.

log-test

Now, create a base class that takes in and is initialized with a Logger. Everything worth logging must inherit from this base class. Create debug_class under program.

1
from src.log.logger import Logger
2

3

4
class Debug_Class:
5
    def __init__(self, logger: Logger):
6
        self._debug = False
7
        self._logger = logger
8

9
    def message(self, content):
10
        if self._debug:
11
            print(content)
12
            self._logger.add_content(content)
13

14
    def set_verbose(self):
15
        self._debug = True

Next would be mouse_coordinate.py under util.

1
from pynput import *
2

3

4
def get_coords(x, y):
5
    print("Now at: {}".format((x, y)))
6

7

8
if __name__ == '__main__':
9
    with mouse.Listener(on_move=get_coords) as listen:
10
        listen.join()

TIP
This script gets the current position of the mouse. I will use it to get the positions of the UI.

Although I don’t know where I can apply this yet, I am fairly sure I am going to need to take screenshots. Let me copy & paste some code from my old screen-scraping projects. Create window_getter.py under util.

1
import platform
2
if platform.platform().startswith('macOS'):
3
    import Quartz
4
import PIL.ImageGrab
5

6

7
def get_window_with_title(title):
8
    def get_window_list_mac():
9
        window_list = []
10
        window_info_list = Quartz.CGWindowListCopyWindowInfo(Quartz.kCGWindowListOptionOnScreenOnly,
11
                                                             Quartz.kCGNullWindowID)
12
        for window_info in window_info_list:
13
            window_list.append(window_info)
14
        return window_list
15

16
    def get_mac_windows():
17
        result = []
18
        for m_window in get_window_list_mac():
19
            m_window_title = m_window.get('kCGWindowOwnerName', 'No Title')
20
            if title in m_window_title:
21
                result.append(m_window)
22
        return result
23

24
    if platform.platform().startswith('macOS'):
25
        windows = get_mac_windows()
26
        if len(windows) > 0:
27
            return windows[0]
28
    else:
29
        return None
30

31

32
def get_screenshot_of_chosen_window(chosen_window):
33
    def run_mac():
34
        bounds = chosen_window.get('kCGWindowBounds')
35
        h = int(bounds.get('Height'))
36
        w = int(bounds.get('Width'))
37
        x = int(bounds.get('X'))
38
        y = int(bounds.get('Y'))
39
        return PIL.ImageGrab.grab(bbox=(x, y, w+x, h+y),
40
                                  include_layered_windows=True,
41
                                  all_screens=True)
42
    if platform.platform().startswith('macOS'):
43
        return run_mac()
44
    else:
45
        return None

Test.

1
if __name__ == '__main__':
2
    chosen_window = get_window_with_title('iPhone Mirroring')
3
    print(chosen_window)
4
    get_screenshot_of_chosen_window(chosen_window).save('screenshot-test.png')

I got

1
{
2
    kCGWindowAlpha = 1;
3
    kCGWindowBounds =     {
4
        Height = 694;
5
        Width = 312;
6
        X = 0;
7
        Y = 25;
8
    };
9
    kCGWindowIsOnscreen = 1;
10
    kCGWindowLayer = 0;
11
    kCGWindowMemoryUsage = 2272;
12
    kCGWindowName = "iPhone Mirroring";
13
    kCGWindowNumber = 6958;
14
    kCGWindowOwnerName = "iPhone Mirroring";
15
    kCGWindowOwnerPID = 11641;
16
    kCGWindowSharingState = 1;
17
    kCGWindowStoreType = 1;
18
}

and

screenshot-test

Let me do just these three for now.

Step 5️⃣#

Now, after I have performed a prestige manually. I think here are the parts I will need to implement.

depot - upgrade trucks
egg_jump
house - upgrade houses
prestige
research
spawner - spawn chickens

Put them under play

play-folder

Also, create ui_position under each of them.

play-folder2

In the following steps, my task will be to implement each of them, and, in the end, I will combine everything together to write the final prestige machine in main.py.

Step 6️⃣#

At last, I am going to implement something related to the game. Let me start with the first thing every player does in the game - spawn chickens.

In spawner/ui_position.py, put

1
spawn_pos = [153, 665]

Create spawner.py under spawner.

1
import time
2
from src.interaction.mouse import Mouse
3
from src.play.spawner.ui_position import spawn_pos
4
from src.program.debug_class import Debug_Class
5

6

7
class Spawner(Debug_Class):
8
    def __init__(self, logger):
9
        super().__init__(logger)
10
        self._mouse = Mouse()
11

12
    async def spawn_chicken(self, duration=2):
13
        self.message(f"Spawn chicken for {duration} seconds.")
14
        self._mouse.click_pos(spawn_pos)
15
        self._mouse.press_pos(spawn_pos, duration)
16
        self.message(f"Resting for {round(duration * 0.75, 2)} seconds.")
17
        time.sleep(duration * 0.75)

TIP
spawn_chicken sends chickens for duration seconds and release for duration * 0.75 seconds.

Now test this.

1
import asyncio
2
from src.log.logger import Logger
3

4
async def main():
5
    logger = Logger()
6
    spawner = Spawner(logger)
7
    await spawner.spawn_chicken(10)
8

9
if __name__ == '__main__':
10
    asyncio.run(main())

spawn-test

I can even repeat this.

1
async def spawn_continue(self, times=5, duration=2):
2
    self.message(f"Spawn {times} waves of chicken.")
3
    for i in range(times):
4
        self.message(f"Perform spawn wave {i + 1}.")
5
        await self.spawn_chicken(duration)

Test.

1
import asyncio
2
from src.log.logger import Logger
3

4
async def main():
5
    logger = Logger()
6
    spawner = Spawner(logger)
7
    await spawner.spawn_continue(5, 5)
8

9
if __name__ == '__main__':
10
    asyncio.run(main())

spawn-test2

HOORAY
🎉 This should be everything about spawning chickens.

Step 7️⃣#

The next easiest thing to do is to purchase chicken houses. Create house.py under house.

1
from src.interaction.mouse import Mouse
2
from src.program.debug_class import Debug_Class
3
from src.play.house.ui_position import (house_pos,
4
                                        max_pos1,
5
                                        max_pos2,
6
                                        max_pos3,
7
                                        max_pos4,
8
                                        exit_pos)
9

10
class House(Debug_Class):
11
    def __init__(self, logger):
12
        super().__init__(logger)
13
        self._mouse = Mouse()
14

15
    async def buy_new_house(self):
16
        # go to purchasing house menu
17
        # click multiple times (to prevent drones)
18
        self.message("Open house menu.")
19
        self._mouse.click_pos(house_pos, 0.7)
20
        self._mouse.click_pos(house_pos, 0.7)
21
        self._mouse.click_pos(house_pos, 0.7)
22

23
        # max out houses
24
        self._mouse.click_pos(max_pos1)
25
        self._mouse.click_pos(max_pos2)
26
        self._mouse.click_pos(max_pos3)
27
        self._mouse.click_pos(max_pos4)
28

29
        self.message("Purchased houses.")
30

31
        # exit
32
        self.message("Close menu.")
33
        self._mouse.click_pos(exit_pos, 0.7)

Add the following to house/ui_position.py.

1
house_pos = [183, 227]
2

3
max_pos1 = [121, 363]
4
max_pos2 = [223, 312]
5
max_pos3 = [82, 471]
6
max_pos4 = [223, 471]
7

8
exit_pos = [278, 173]

Test.

1
import asyncio
2
from src.log.logger import Logger
3

4
async def main():
5
    logger = Logger()
6
    house = House(logger)
7
    await house.buy_new_house()
8

9
if __name__ == '__main__':
10
    asyncio.run(main())

house-test

Step 8️⃣#

After buying houses, now I need trucks. For simplicity, let me just buy 4. Create depot.py under depot.

1
from src.interaction.mouse import Mouse
2
from src.play.depot.ui_position import (depot_pos,
3
                                        max_pos1,
4
                                        max_pos2,
5
                                        max_pos3,
6
                                        max_pos4,
7
                                        exit_pos)
8
from src.program.debug_class import Debug_Class
9

10

11
class Depot(Debug_Class):
12
    def __init__(self, logger):
13
        super().__init__(logger)
14
        self._mouse = Mouse()
15

16
    async def buy_new_trucks(self):
17
        self.message("Open shipping menu.")
18
        self._mouse.click_pos(depot_pos, 0.7)
19
        self._mouse.click_pos(depot_pos, 0.7)
20
        self._mouse.click_pos(depot_pos, 0.7)
21

22
        # max out trucks
23
        self._mouse.click_pos(max_pos1)
24
        self._mouse.click_pos(max_pos2, once=True)
25
        self._mouse.click_pos(max_pos3, once=True)
26
        self._mouse.click_pos(max_pos4, once=True)
27

28
        self.message("Purchased trucks.")
29

30
        # exit
31
        self.message("Close menu.")
32
        self._mouse.click_pos(exit_pos, 0.7)

Add the following to depot/ui_position.py.

1
depot_pos = [175, 469]
2

3
max_pos1 = [266, 292]
4
max_pos2 = [247, 354]
5
max_pos3 = [247, 406]
6
max_pos4 = [247, 451]
7

8
exit_pos = [278, 173]

Test.

1
import asyncio
2
from src.log.logger import Logger
3

4
async def main():
5
    logger = Logger()
6
    depot = Depot(logger)
7
    await depot.buy_new_trucks()
8

9
if __name__ == '__main__':
10
    asyncio.run(main())

truck-test

Step 9️⃣#

So far, things haven’t been very interesting. That’s why in the next step I’m going to make the program capable of upgrading Research. I’ll need to figure out a way for it to locate the upgrade buttons.

Fortunately, I’ve done this before. The high-level idea is to first pixelate the screenshot, crop out the green button, and save it as a template. Then, apply template matching to identify the positions of the buttons in the pixelated screenshot. Finally, map these positions back to the original screenshot, and voilà—the program knows where to press!

Let’s start coding! Create research.py under research.

1
import os
2
import cv2
3
import time
4
import numpy as np
5
from PIL import Image
6
from src.interaction.mouse import Mouse
7
from src.play.spawner.spawner import Spawner
8
from src.program.debug_class import Debug_Class
9
from src.util.window_getter import get_screenshot_of_chosen_window, get_window_with_title
10
from src.play.research.ui_position import (research_pos,
11
                                           drag_from,
12
                                           drag_to,
13
                                           exit_pos)
14

15

16
class Research(Debug_Class):
17
    def __init__(self, window, logger):
18
        super().__init__(logger)
19
        self._mouse = Mouse()
20
        self._window = window

Put these in research/ui_position.py.

1
research_pos = [31, 601]
2

3
drag_from = [70, 540]
4
drag_to = [70, 380]
5

6
exit_pos = [285, 164]

Next let me use this screenshot as an example and I will be finding all upgrade buttons in it.

research-test2

The first step is to pixelate this screenshot.

1
def pixelate(pil_image, factor):
2
    width, height = pil_image.size
3

4
    # assuming factor = 3
5
    # calculate the new dimensions (each 3x3 block becomes 1 pixel)
6
    new_width = width // factor
7
    new_height = height // factor
8

9
    # create a new image with the new dimensions
10
    new_image = Image.new("RGB", (new_width, new_height))
11

12
    for i in range(new_width):
13
        for j in range(new_height):
14
            # initialize RGB accumulators
15
            r_total, g_total, b_total = 0, 0, 0
16

17
            # sum the colors in the 3x3 block
18
            for x in range(factor):
19
                for y in range(factor):
20
                    # get the pixel at the current position
21
                    pixel = pil_image.getpixel((i * factor + x, j * factor + y))
22
                    r_total += pixel[0]
23
                    g_total += pixel[1]
24
                    b_total += pixel[2]
25

26
            # calculate the average color
27
            r_avg = r_total // (factor * factor)
28
            g_avg = g_total // (factor * factor)
29
            b_avg = b_total // (factor * factor)
30

31
            # set the average color in the new image
32
            new_image.putpixel((i, j), (r_avg, g_avg, b_avg))
33

34
    return new_image

Now let me test this. I want the pixel factor to be 5.

screenshot-pixelated

That worked pretty well, but there is no need to process the entire image. However, that being said, for simplicity. I am not going to show how to optimize this.

Next I will save the green button template. It’s very small.

TIP
Here you can get your own template by using a pixel art editor.

After we have the template, we can use it.

1
script_dir = os.path.dirname(os.path.abspath(__file__))
2
self._template = cv2.imread(os.path.join(script_dir, 'button-template.png'))
3

4

5
def _get_research_position(self, screenshot, factor=5, similarity=0.97):
6
    result = match_position(self._template, pil_to_cv2(pixelate(screenshot, factor)), similarity)
7
    if result[1]:
8
        # map back to the original position
9
        return [int(item) * factor for item in list(result[1][0])]
10
    return None

Here is pil_to_cv2.

1
def pil_to_cv2(pil_image):
2
    pil_image = pil_image.convert('RGB')
3
    rgb_array = np.array(pil_image)
4
    bgr_image = cv2.cvtColor(rgb_array, cv2.COLOR_RGB2BGR)
5
    return bgr_image

Here is match_position.

1
def match_position(template, screenshot, similarity=0.97):
2
    # separate the alpha channel if present
3
    bgr_template = template[:, :, :3] if template.shape[2] == 4 else template
4

5
    # perform template matching
6
    result = cv2.matchTemplate(screenshot, bgr_template, cv2.TM_CCORR_NORMED)
7

8
    # get all locations with similarity above the threshold
9
    match_locations = np.where(result >= similarity)
10

11
    # get the size of the template
12
    template_h, template_w = bgr_template.shape[:2]
13

14
    # create a copy of the screenshot for visualization
15
    screenshot_with_dots = screenshot.copy()
16

17
    # calculate and draw the center positions
18
    centers = []
19
    for (x, y) in zip(match_locations[1], match_locations[0]):
20
        center_x = x + template_w // 2
21
        center_y = y + template_h // 2
22
        centers.append((center_x, center_y))
23

24
        # draw a red dot at the center
25
        # cv2.circle(screenshot_with_dots, (center_x, center_y), radius=1, color=(0, 0, 255), thickness=0)
26

27
    return screenshot_with_dots, centers

Test for template matching in pixelated image.

1
from src.log.logger import Logger
2

3

4
if __name__ == '__main__':
5
    chosen_window = get_window_with_title('iPhone Mirroring')
6
    logger = Logger()
7
    research = Research(chosen_window, logger)
8
    screenshot = Image.open('research-test2.png')
9
    print(research._get_research_position(screenshot))

TIP
Troubleshoot: If you see error like AttributeError: 'NoneType' object has no attribute 'shape'. It’s very likely that your project is missing the screenshot and template.

Put this image ⬇️ under research and name it research-test2.png.

research-test2

Put this image ⬇️ under research and name it button-template.png. (It’s a 10 x 7 green image, very small.)

Output:

1
[255, 225]

This position in the screenshot.

research-test2-dotted

BTW, match_position actually finds all of them. The program only took the first.

research-test3

It’s in a good shape. Next I can make it to do some upgrades.

1
def _determine_research(self, factor=5, press_duration=2):
2
    screenshot = get_screenshot_of_chosen_window(self._window)
3
    position = self._get_research_position(screenshot, factor)
4
    while position:
5
        self.message(f"Pressing ({position[0]}, {position[1]+25})")
6
        # added 25 to fix margin error
7
        self._mouse.press(position[0], position[1]+25, press_duration)
8
        screenshot = get_screenshot_of_chosen_window(self._window)
9
        position = self._get_research_position(screenshot, factor)

research-test4

Create a loop to make this process repeated.

1
async def do_research(self, iterations=12, press_duration=2, check_wait=2):
2
    # go to the research menu
3
    self.message("Open research menu.")
4
    self._mouse.click_pos(research_pos, 0.4)
5

6
    self.message(f"Leveling up, total iterations: {iterations}.")
7
    # level up researches
8
    for i in range(iterations):
9
        start_time = time.time()
10
        self.message(f"Performing iteration {i+1}.")
11
        self._determine_research(factor=5, press_duration=press_duration)
12
        self.message("Time spent on this iteration: --- %s seconds ---" % (time.time() - start_time))
13
        time.sleep(check_wait)
14
        self._drag_menu(drag_duration=1)
15

16
    self.message("Close menu.")
17
    self._mouse.click_pos(exit_pos)
18
    time.sleep(1)
19

20
def _drag_menu(self, drag_duration=1.0):
21
    self._mouse.perform_drag(drag_from, drag_to, drag_duration)

Test.

1
import asyncio
2
from src.log.logger import Logger
3

4

5
async def main():
6
    chosen_window = get_window_with_title('iPhone Mirroring')
7
    logger = Logger()
8
    research = Research(chosen_window, logger)
9
    await research.do_research(15)
10

11

12
if __name__ == '__main__':
13
    asyncio.run(main())

research-test5

HOORAY
🎉 The program is performing pretty well. Here is the result after a research upgrade loop by the program.

Step 1️⃣0️⃣#

Recall the pattern:

Start from Edible
Jump to Dilithium

…

My Earning Bonus allows me to jump to Dilithium from a fresh Edible farm.

egg-jump1

This should be similar to purchasing houses and trucks. (It’s actually not, I am only presenting the barely minimum version that gets the job down.)

Create egg_jump.py under egg_jump.

1
from src.interaction.mouse import Mouse
2
from src.program.debug_class import Debug_Class
3
from src.play.egg_jump.ui_position import (egg_pos,
4
                                           upgrade_pos,
5
                                           yes_pos,
6
                                           exit_pos)
7

8
class Egg_Jump(Debug_Class):
9
    def __init__(self, logger):
10
        super().__init__(logger)
11
        self._mouse = Mouse()
12

13
    async def jump(self):
14
        self.message("Open egg jump menu.")
15
        self._mouse.click_pos(egg_pos, 0.7)
16

17
        self.message("Perform egg jump.")
18
        self._mouse.click_pos(upgrade_pos, 0.7)
19
        self._mouse.click_pos(yes_pos, 0.7)
20

21
        self.message("Close menu.")
22
        self._mouse.click_pos(exit_pos)

Add the following to egg_jump/ui_position:

1
egg_pos = [38, 122]
2
upgrade_pos = [158, 435]
3
yes_pos = [197, 299]
4
exit_pos = [285, 164]

Test.

1
import asyncio
2
from src.log.logger import Logger
3

4

5
async def main():
6
    logger = Logger()
7
    egg_jump = Egg_Jump(logger)
8
    await egg_jump.jump()
9

10

11
if __name__ == '__main__':
12
    asyncio.run(main())

egg-jump2

Step 1️⃣1️⃣#

The next two steps are:

Get enough farm value and jump to Universe
Get soul eggs and prestige

Let me skip ‘Get enough farm value and jump to Universe’ for now.

‘Prestige’ is a very easy step. Create prestige.py under prestige.

1
from src.interaction.mouse import Mouse
2
from src.program.debug_class import Debug_Class
3
from play.prestige.ui_position import (egg_pos,
4
                                       prestige_info_pos,
5
                                       prestige_and_collect_pos,
6
                                       yes_button)
7

8

9
class Prestige(Debug_Class):
10
    def __init__(self, logger):
11
        super().__init__(logger)
12
        self._mouse = Mouse()
13

14
    async def start_new_farm(self):
15
        self.message("Open prestige menu.")
16
        self._mouse.click_pos(egg_pos, 0.7)
17
        self._mouse.click_pos(prestige_info_pos, 0.7)
18
        self._mouse.click_pos(prestige_and_collect_pos, 0.7)
19
        self.message("Confirm prestige.")
20
        self._mouse.click_pos(yes_button, 0.7)

Add the following to prestige/ui_position:

1
egg_pos = [38, 122]
2
prestige_info_pos = [161, 482]
3
prestige_and_collect_pos = [157, 500]
4
yes_button = [194, 299]

Test.

1
import asyncio
2
from src.log.logger import Logger
3

4

5
async def main():
6
    logger = Logger()
7
    prestige = Prestige(logger)
8
    await prestige.start_new_farm()
9

10

11
if __name__ == '__main__':
12
    asyncio.run(main())

fresh-farm

Step 1️⃣2️⃣#

Now I will start filling main.py. Every thing will come together in this step.

1
import time
2
import asyncio
3
from src.play.spawner.spawner import Spawner
4
from src.play.egg_jump.egg_jump import Egg_Jump
5
from src.play.house.house import House
6
from src.play.depot.depot import Depot
7
from src.play.research.research import Research
8
from src.util.window_getter import get_window_with_title
9
from src.play.prestige.prestige import Prestige
10
from src.log.logger import Logger
11

12

13
async def main(window, logger: Logger, run_num=0, debug=True):
14
    logger.add_content(f"--- Prestige run {run_num} starts. ---")
15
    start_time = time.time()
16

17
    spawner = Spawner(logger=logger)
18
    # assuming Edible
19
    # go to Dilithium
20
    egg_jump = Egg_Jump(logger=logger)
21
    if debug:
22
        spawner.set_verbose()
23
        egg_jump.set_verbose()
24
    # guarantees to succeed
25
    await egg_jump.jump()
26
    # animation
27
    time.sleep(5)
28

29
    # now in Dilithium
30
    # Start by spawning chickens for 5 seconds
31
    await spawner.spawn_chicken(5)
32
    time.sleep(0.5)
33

34
    # buy houses
35
    house = House(logger=logger)
36
    if debug:
37
        house.set_verbose()
38
    await house.buy_new_house()
39
    time.sleep(0.5)
40

41
    # buy trucks
42
    depot = Depot(logger=logger)
43
    if debug:
44
        depot.set_verbose()
45
    await depot.buy_new_trucks()
46
    time.sleep(0.5)
47

48
    # research
49
    research = Research(window=window, logger=logger)
50
    if debug:
51
        research.set_verbose()
52
    await research.do_research(12, 1, 0.1)
53

54
    await egg_jump.jump()
55
    # animation
56
    time.sleep(5)
57

58
    # now in universe
59
    # start by spawning chickens for 5 seconds
60
    await spawner.spawn_chicken(5)
61
    time.sleep(5)
62

63
    # buy houses
64
    await house.buy_new_house()
65
    time.sleep(0.5)
66

67
    # buy trucks
68
    await depot.buy_new_trucks()
69
    time.sleep(0.5)
70

71
    # Research
72
    await research.do_research(20, 1, 0.1)
73

74
    # raise more chicken
75
    await spawner.spawn_continue(10)
76

77
    await depot.buy_new_trucks()
78
    time.sleep(0.5)
79

80
    # raise more chicken
81
    await spawner.spawn_continue(20)
82

83
    prestige = Prestige(logger=logger)
84
    if debug:
85
        prestige.set_verbose()
86
    await prestige.start_new_farm()
87

88
    logger.add_content(f"--- Prestige run {run_num} ends. ---")
89
    logger.add_content(f"Time spent for this run : --- %s seconds ---" % (time.time() - start_time))
90
    time.sleep(6)
91

92

93
if __name__ == '__main__':
94
    logger = Logger()
95
    chosen_window = get_window_with_title('iPhone Mirroring')
96
    counter = 0
97
    try:
98
        while True:
99
            asyncio.run(main(chosen_window, logger, counter))
100
            counter += 1
101
    except KeyboardInterrupt:
102
        logger.save_content()

The result I got after one prestige.

1
--- Prestige run 0 starts. ---
2
Open egg jump menu.
3
Perform egg jump.
4
...
5
--- Prestige run 0 ends. ---
6
Time spent for this run : --- 692.892648935318 seconds ---

TIP
I got this result using an optimized version. Yours is very likely to encounter problems. Some debugging suggestions:

check if during any step, the program did too many clicks.

check if during any step, the program missed a click.

check if the game has lost focus. If yes, you will have to regain focus. Hint: open a random menu and close it.

💗 If you liked this blog, consider following me on GitHub.

🍯 Happy Coding 🍯