clear() world_size = get_world_size() change_hat(Hats.Brown_Hat) companion_mapping = {} hay_mapping = {} def track_companion(curr_x, curr_y): global companion_mapping global hay_mapping result = get_companion() if result == None: return False target_entity, (target_x, target_y) = result if (target_x, target_y) not in companion_mapping: companion_mapping[(target_x, target_y)] = target_entity hay_mapping[(curr_x, curr_y)] = (target_x, target_y) return True return False def drone_hay_task(): global world_size global companion_mapping global hay_mapping while True: for j in range(world_size): curr_x = get_pos_x() curr_y = get_pos_y() harvest() if get_ground_type() == Grounds.Soil: till() if (curr_x, curr_y) in companion_mapping: target_entity = companion_mapping[(curr_x, curr_y)] if target_entity == Entities.Carrot: if get_ground_type() != Grounds.Soil: till() plant(Entities.Carrot) elif target_entity != Entities.Grass: plant(target_entity) else: if (curr_x, curr_y) in hay_mapping: companion_pos = hay_mapping.pop((curr_x, curr_y)) if companion_pos in companion_mapping: companion_mapping.pop(companion_pos) track_companion(curr_x, curr_y) move(North) NUM_DRONES_TO_SPAWN = world_size - 1 for i in range(NUM_DRONES_TO_SPAWN): while num_drones() >= max_drones(): pass spawn_drone(drone_hay_task) move(East) drone_hay_task()

companion_mapping = {} hay_mapping = {} def track_companion(): global companion_mapping global hay_mapping target_entity, (target_x, target_y) = get_companion() while target_entity == Entities.Carrot and num_items(Items.Wood) < 1: harvest() target_entity, (target_x, target_y) = get_companion() if (target_x, target_y) not in companion_mapping: companion_mapping[(target_x, target_y)] = target_entity hay_mapping[(x_curr, y_curr)] = (target_x, target_y) while True: if num_items(Items.Hay) >= 1000000000000: break x_curr = get_pos_x() y_curr = get_pos_y() if get_entity_type() == Entities.Grass: if can_harvest(): harvest() if (x_curr, y_curr) in hay_mapping: # Had a companion that was already planted companion_pos = hay_mapping[(x_curr, y_curr)] hay_mapping.pop((x_curr, y_curr)) companion_mapping.pop(companion_pos) if (x_curr, y_curr) in companion_mapping: # Plant a companion target_entity = companion_mapping[(x_curr, y_curr)] if target_entity not in [Entities.Bush, Entities.Tree]: till() plant(target_entity) else: # Only when current position is growing grass track_companion() else: # Entity is not grass AKA it is / was a companion if (x_curr, y_curr) not in companion_mapping: # Companion has served its purpose # Reset land back to grassland if get_ground_type() != Grounds.Grassland: till() else: harvest() track_companion() if y_curr == get_world_size() - 1: move(East) move(North)

clear() world_size = get_world_size() change_hat(Hats.Brown_Hat) companion_mapping = {} tree_mapping = {} def tree_tile(curr_x, curr_y): return curr_x % 2 == curr_y % 2 def track_companion(curr_x, curr_y): global companion_mapping global tree_mapping result = get_companion() if result == None: return False target_entity, (target_x, target_y) = result if (target_x, target_y) not in companion_mapping: companion_mapping[(target_x, target_y)] = target_entity tree_mapping[(curr_x, curr_y)] = (target_x, target_y) return True return False def drone_tree_task(): global world_size global companion_mapping global tree_mapping while True: for j in range(world_size): curr_x = get_pos_x() curr_y = get_pos_y() if tree_tile(curr_x, curr_y): if can_harvest(): harvest() plant(Entities.Tree) else: pass if (curr_x, curr_y) in tree_mapping: companion_pos = tree_mapping.pop((curr_x, curr_y)) if companion_pos in companion_mapping: companion_mapping.pop(companion_pos) track_companion(curr_x, curr_y) if get_water() < 0.40: use_item(Items.Water) elif (curr_x, curr_y) in companion_mapping: target_entity = companion_mapping[(curr_x, curr_y)] harvest() if target_entity == Entities.Grass: if get_ground_type() != Grounds.Grassland: till() elif target_entity == Entities.Carrot: if get_ground_type() != Grounds.Soil: till() plant(target_entity) else: harvest() plant(Entities.Bush) move(North) NUM_DRONES_TO_SPAWN = 31 for i in range(NUM_DRONES_TO_SPAWN): while num_drones() >= max_drones(): pass  spawn_drone(drone_tree_task) move(East) drone_tree_task()

world_size = get_world_size() target_num = 10000000000 companion_mapping = {} tree_mapping = {} def track_companion(curr_x, curr_y): global companion_mapping global hay_mapping target_entity, (target_x, target_y) = get_companion() if not tree_tile(target_x, target_y) and (target_x, target_y) not in companion_mapping: companion_mapping[(target_x, target_y)] = target_entity tree_mapping[(curr_x, curr_y)] = (target_x, target_y) return True return False def tree_tile(curr_x, curr_y): return curr_x % 2 == curr_y % 2 while True: curr_x = get_pos_x() curr_y = get_pos_y() if tree_tile(curr_x, curr_y): if (curr_x, curr_y) in tree_mapping: while not can_harvest(): use_item(Items.Fertilizer) harvest() plant(Entities.Tree) if (curr_x, curr_y) in tree_mapping: # Had a companion that was already planted companion_pos = tree_mapping[(curr_x, curr_y)] tree_mapping.pop((curr_x, curr_y)) companion_mapping.pop(companion_pos) if track_companion(curr_x, curr_y) and get_water() < 0.10: use_item(Items.Water) elif (curr_x, curr_y) in companion_mapping: target_entity = companion_mapping[(curr_x, curr_y)] curr_entity = get_entity_type() harvest() if target_entity == Entities.Grass: if get_ground_type() != Grounds.Grassland: # Grass that needs tilling. Grass never needs any planting though. till() elif target_entity == Entities.Carrot and get_ground_type() != Grounds.Soil: # Carrot that needs tilling till() plant(target_entity) else: # Not grass, but does not need any tilling. plant(target_entity) else: # not a tree tile, but is not a companion harvest() plant(Entities.Bush) if num_items(Items.Wood) >= target_num: break move(North) curr_y = get_pos_y() if curr_y == world_size - 1: move(East)

clear() world_size = get_world_size() change_hat(Hats.Brown_Hat) companion_mapping = {} carrot_mapping = {} def track_companion(curr_x, curr_y): global companion_mapping global carrot_mapping result = get_companion() if result == None: return False target_entity, (target_x, target_y) = result if (target_x, target_y) not in companion_mapping: companion_mapping[(target_x, target_y)] = target_entity carrot_mapping[(curr_x, curr_y)] = (target_x, target_y) return True return False def prepare_and_plant(entity_type): if entity_type in (Entities.Carrot, Entities.Bush, Entities.Tree) and get_ground_type() != Grounds.Soil: till() plant(entity_type) def drone_carrot_task(): global world_size global companion_mapping global carrot_mapping while True: for j in range(world_size): curr_x = get_pos_x() curr_y = get_pos_y() harvest() if (curr_x, curr_y) in companion_mapping: target_entity = companion_mapping[(curr_x, curr_y)] prepare_and_plant(target_entity) if target_entity == Entities.Carrot and get_water() < 0.10: use_item(Items.Water) elif (curr_x, curr_y) in carrot_mapping: prepare_and_plant(Entities.Carrot) if get_water() < 0.10: use_item(Items.Water) companion_pos = carrot_mapping.pop((curr_x, curr_y)) if companion_pos in companion_mapping: companion_mapping.pop(companion_pos) track_companion(curr_x, curr_y) else: prepare_and_plant(Entities.Carrot) if get_water() < 0.10: use_item(Items.Water) track_companion(curr_x, curr_y) move(North) NUM_DRONES_TO_SPAWN = world_size - 1 for i in range(NUM_DRONES_TO_SPAWN): while num_drones() >= max_drones(): pass spawn_drone(drone_carrot_task) move(East) drone_carrot_task()

clear() set_world_size(max_drones() - 1) change_hat(Hats.Brown_Hat) hats = [Hats.Green_Hat, Hats.Purple_Hat] world_size = get_world_size() def plant_crop(i, j): if (i + j) % 2 == 0: plant(Entities.Tree) else: plant(Entities.Carrot) if get_water() < 0.5: use_item(Items.Water) def run_drone(): global hats change_hat(hats[get_pos_x() % 2]) for j in range(get_world_size()): if get_ground_type() != Grounds.Soil: till() plant_crop(get_pos_x(), j) if can_harvest(): harvest() plant_crop(get_pos_x(), j) move(North) def run_carrots_trees(): global world_size for i in range(world_size): spawn_drone(run_drone) while num_drones() >= max_drones(): pass move(East) while True: run_carrots_trees()

clear() change_hat(Hats.Brown_Hat) hats = [Hats.Green_Hat, Hats.Purple_Hat] world_size = get_world_size() max_petals = 15 min_petals = 7 def replant_systematically(): harvest() if get_ground_type() != Grounds.Soil: till() plant(Entities.Sunflower) if get_water() < 0.5: use_item(Items.Water) def create_worker_task(target_petal, is_replant_phase): def encapsulated_worker_task(): if get_pos_x() < world_size - 1: change_hat(hats[get_pos_x() % 2]) for j in range(world_size): if measure() == target_petal: while not can_harvest(): use_item(Items.Fertilizer) harvest() if is_replant_phase: if get_entity_type() != Entities.Sunflower: replant_systematically() move(North) return return encapsulated_worker_task def drone_task_initial_setup(): for j in range(world_size): if can_harvest(): harvest() replant_systematically() move(North) return def drone_task_manager(): global world_size change_hat(Hats.Brown_Hat) first_run = True while True: if first_run: for i in range(world_size - 1): spawn_drone(drone_task_initial_setup) move(East) drone_task_initial_setup() move(East) first_run = False for petal_count in range(max_petals, min_petals, -1): worker_task = create_worker_task(petal_count, False) for i in range(world_size - 1): spawn_drone(worker_task) move(East) worker_task() move(East) worker_task_replant_total = create_worker_task(min_petals, True) for i in range(world_size - 1): spawn_drone(worker_task_replant_total) move(East) worker_task_replant_total() move(East) def run_sunflower(): drone_task_manager() while True: run_sunflower()

clear() change_hat(Hats.Brown_Hat) world_size = get_world_size() first_pass = True def check_pumpkin(): if get_pos_x() != 0: move(East) left_id = measure() move(West) right_id = measure() move(East) return left_id == right_id def wait_for_drones(drones): for drone in drones: wait_for(drone) def plant_column(): global world_size global first_pass for j in range(world_size): if get_entity_type() != Entities.Pumpkin: if get_ground_type() != Grounds.Soil: till() plant(Entities.Pumpkin) if not first_pass: while not can_harvest(): if get_entity_type() == Entities.Dead_Pumpkin: plant(Entities.Pumpkin) use_item(Items.Fertilizer) move(North) if not first_pass: for j in range(world_size): if get_entity_type() == Entities.Dead_Pumpkin: plant(Entities.Pumpkin) move(North) def plant_pumpkins(): global world_size global first_pass drones = [] if get_pos_x() != 0: move(East) for i in range(world_size - 1): drones.append(spawn_drone(plant_column)) move(East) plant_column() wait_for_drones(drones) while True: plant_pumpkins() first_pass = False if check_pumpkin(): harvest() first_pass = True move(West)

clear() hats = [Hats.Green_Hat, Hats.Purple_Hat] world_size = get_world_size() def _shortest_delta(curr, dest): size = world_size d = (dest - curr) % size if d > size / 2: d -= size return d def move_to_x_pos(x_target): x_curr = get_pos_x() moves_needed = _shortest_delta(x_curr, x_target) if moves_needed > 0: dir = East else: dir = West for i in range(abs(moves_needed)): move(dir) def move_to_y_pos(y_target): y_curr = get_pos_y() moves_needed = _shortest_delta(y_curr, y_target) if moves_needed > 0: dir = North else: dir = South for i in range(abs(moves_needed)): move(dir) def wait_for_drones(drones): for drone in drones: wait_for(drone) def drone_action_plant_cacti(): global world_size change_hat(hats[get_pos_x() % 2]) for j in range(world_size): if get_ground_type() != Grounds.Soil: till() plant(Entities.Cactus) move(North) def plant_cacti(): global world_size move_to_x_pos(0) move_to_y_pos(0) drones = [] for i in range(world_size - 1): drones.append(spawn_drone(drone_action_plant_cacti)) move(East) drone_action_plant_cacti() move(East) move(North) wait_for_drones(drones) def shake_row(): global world_size change_hat(hats[get_pos_y() % 2]) left = 0 right = world_size - 1 while left < right: move_to_x_pos(left) loc_last_swap = left x_curr = get_pos_x() while x_curr < right: if measure() > measure(East): swap(East) loc_last_swap = x_curr move(East) x_curr += 1 right = loc_last_swap if left >= right: break move_to_x_pos(right) loc_last_swap = right x_curr = get_pos_x() while x_curr > left: if measure(West) > measure(): swap(West) loc_last_swap = x_curr move(West) x_curr -= 1 left = loc_last_swap def shake_col(): global world_size change_hat(hats[get_pos_x() % 2]) left = 0 right = world_size - 1 while left < right: move_to_y_pos(left) loc_last_swap = left y_curr = get_pos_y() while y_curr < right: if measure() > measure(North): swap(North) loc_last_swap = y_curr move(North) y_curr += 1 right = loc_last_swap if left >= right: break move_to_y_pos(right) loc_last_swap = right y_curr = get_pos_y() while y_curr > left: if measure(South) > measure(): swap(South) loc_last_swap = y_curr move(South) y_curr -= 1 left = loc_last_swap def sort_columns(): global world_size move_to_x_pos(0) move_to_y_pos(0) drones = [] for i in range(world_size - 1): drones.append(spawn_drone(shake_col)) move(East) shake_col() move(East) move(North) wait_for_drones(drones) def sort_rows(): global world_size move_to_x_pos(0) move_to_y_pos(0) drones = [] for i in range(world_size - 1): drones.append(spawn_drone(shake_row)) move(North) shake_row() move(North) wait_for_drones(drones) while True: plant_cacti() sort_columns() sort_rows() harvest()

clear() hats = [Hats.Green_Hat, Hats.Purple_Hat] set_world_size(6) world_size = get_world_size() def _shortest_delta(curr, dest): size = world_size d = (dest - curr) % size if d > size / 2: d -= size return d def move_to_x_pos(x_target): x_curr = get_pos_x() moves_needed = _shortest_delta(x_curr, x_target) if moves_needed > 0: dir = East else: dir = West for i in range(abs(moves_needed)): move(dir) def move_to_y_pos(y_target): y_curr = get_pos_y() moves_needed = _shortest_delta(y_curr, y_target) if moves_needed > 0: dir = North else: dir = South for i in range(abs(moves_needed)): move(dir) def wait_for_drones(drones): for drone in drones: wait_for(drone) def drone_action_plant_cacti(): global world_size change_hat(hats[get_pos_x() % 2]) for j in range(world_size): if get_ground_type() != Grounds.Soil: till() plant(Entities.Cactus) move(North) def plant_cacti(): global world_size move_to_x_pos(0) move_to_y_pos(0) drones = [] for i in range(world_size - 1): drones.append(spawn_drone(drone_action_plant_cacti)) move(East) drone_action_plant_cacti() move(East) move(North) wait_for_drones(drones) def shake_row(): global world_size change_hat(hats[get_pos_y() % 2]) left = 0 right = world_size - 1 while left < right: move_to_x_pos(left) loc_last_swap = left x_curr = get_pos_x() while x_curr < right: # Condition inversée pour le passage Est/droite : # Si l'élément courant est PLUS PETIT que le suivant, on échange. if measure() < measure(East): swap(East) loc_last_swap = x_curr move(East) x_curr += 1 right = loc_last_swap if left >= right: break move_to_x_pos(right) loc_last_swap = right x_curr = get_pos_x() while x_curr > left: # Condition inversée pour le passage Ouest/gauche : # Si l'élément précédent est PLUS GRAND que le courant, on échange. if measure(West) > measure(): swap(West) loc_last_swap = x_curr move(West) x_curr -= 1 left = loc_last_swap def shake_col(): global world_size change_hat(hats[get_pos_x() % 2]) left = 0 right = world_size - 1 while left < right: move_to_y_pos(left) loc_last_swap = left y_curr = get_pos_y() while y_curr < right: # Condition inversée pour le passage Nord/haut : # Si l'élément courant est PLUS PETIT que le suivant, on échange. if measure() < measure(North): swap(North) loc_last_swap = y_curr move(North) y_curr += 1 right = loc_last_swap if left >= right: break move_to_y_pos(right) loc_last_swap = right y_curr = get_pos_y() while y_curr > left: # Condition inversée pour le passage Sud/bas : # Si l'élément précédent est PLUS GRAND que le courant, on échange. if measure(South) > measure(): swap(South) loc_last_swap = y_curr move(South) y_curr -= 1 left = loc_last_swap def sort_columns(): global world_size move_to_x_pos(0) move_to_y_pos(0) drones = [] for i in range(world_size - 1): drones.append(spawn_drone(shake_col)) move(East) shake_col() move(East) move(North) wait_for_drones(drones) def sort_rows(): global world_size move_to_x_pos(0) move_to_y_pos(0) drones = [] for i in range(world_size - 1): drones.append(spawn_drone(shake_row)) move(North) shake_row() move(North) wait_for_drones(drones) while True: plant_cacti() sort_columns() sort_rows() harvest()

world_size = get_world_size() world_size_minus_one = world_size - 1 edge_positions = [0, world_size_minus_one] offlimit_columns_stage1 = { } offlimit_columns_stage2 = { } clear() change_hat(Hats.Dinosaur_Hat) apple_pos = measure() squares_occupied = 1 game_complete = False aggressive_stage = True def measure_apple(): global apple_pos global squares_occupied global apple_pos_queue apple_pos = measure() squares_occupied += 1 def move_and_check_apple(direction): global apple_pos if not move(direction): return False if (get_pos_x(), get_pos_y()) == apple_pos: measure_apple() return True def move_to_col(target_x_pos, do_measure=True): global world_size global apple_pos curr_x = get_pos_x() direction = West if curr_x < target_x_pos: direction = East for x in range(abs(target_x_pos - curr_x)): this_check = move if do_measure: this_check = move_and_check_apple if not this_check(direction): return False return True def move_to_row(target_y_pos, do_measure=True): global world_size global apple_pos curr_y = get_pos_y() direction = South if curr_y < target_y_pos: direction = North for y in range(abs(target_y_pos - curr_y)): this_check = move if do_measure: this_check = move_and_check_apple if not this_check(direction): return False return True def transition_to_stage_2(): global offlimit_columns_stage1 global world_size global world_size_minus_one move_to_col(world_size_minus_one) move_to_row(0) offlimit_columns_stage1 = { } return False def transition_to_stage_1(): global offlimit_columns_stage2 global world_size global world_size_minus_one move_to_col(0) move_to_row(world_size_minus_one) offlimit_columns_stage2 = { } return False def stage_1_apple_collect(): global apple_pos global world_size global offlimit_columns_stage1 global offlimit_columns_stage2 global world_size_minus_one apple_pos_x, apple_pos_y = apple_pos if apple_pos_y == 0 or apple_pos_x in edge_positions or (apple_pos_x in offlimit_columns_stage1 and apple_pos_y <= offlimit_columns_stage1[apple_pos_x]): return transition_to_stage_2() else: apple_x_odd = apple_pos_x % 2 target_x_pos = apple_pos_x if not apple_x_odd: target_x_pos = apple_pos_x - 1 if target_x_pos <= get_pos_x(): return transition_to_stage_2() else: move_to_col(target_x_pos) move_to_row(apple_pos_y) offlimit_columns_stage2[target_x_pos] = apple_pos_y offlimit_columns_stage2[target_x_pos + 1] = apple_pos_y move_and_check_apple(East) move_to_row(world_size_minus_one) return True def stage_2_apple_collect(): global apple_pos global world_size global offlimit_columns_stage1 global offlimit_columns_stage2 global world_size_minus_one apple_pos_x, apple_pos_y = apple_pos if apple_pos_y == world_size_minus_one or apple_pos_x in edge_positions or (apple_pos_x in offlimit_columns_stage2 and apple_pos_y >= offlimit_columns_stage2[apple_pos_x]): return transition_to_stage_1() else: apple_x_odd = apple_pos_x % 2 target_x_pos = apple_pos_x if apple_x_odd: target_x_pos = apple_pos_x + 1 if target_x_pos >= get_pos_x(): return transition_to_stage_1() else: move_to_col(target_x_pos) move_to_row(apple_pos_y) offlimit_columns_stage1[target_x_pos] = apple_pos_y offlimit_columns_stage1[target_x_pos - 1] = apple_pos_y move_and_check_apple(West) move_to_row(0) return True def move_to_right_col_wavy(): global world_size global world_size_minus_one global offlimit_columns_stage1 # Assume curr x is zero for x in range(world_size): if x % 2: target_y = 1 if x in offlimit_columns_stage1: target_y = offlimit_columns_stage1[x] + 1 while get_pos_y() != target_y: move(South) move(East) else: # x is even, go up to top row, then move right while get_pos_y() != world_size_minus_one: move(North) move(East) def find_top_left(): global world_size_minus_one while get_pos_x() > 0: move(West) while get_pos_y() < world_size_minus_one: move(North) def transition_to_route(): find_top_left() move_to_right_col_wavy() while get_pos_y() != 0: move(South) while get_pos_x() != 0: move(West) # STAGE 1 move_to_row(world_size_minus_one) while aggressive_stage: while stage_1_apple_collect() and get_pos_x() < world_size_minus_one: pass while stage_2_apple_collect() and get_pos_x() > 0: pass if squares_occupied > (world_size_minus_one) * 4 - 4: break transition_to_route() while True: for i in range(world_size / 2): game_complete = not move_to_row(world_size_minus_one, False) game_complete = game_complete or not move(East) game_complete = game_complete or not move_to_row(1, False) if i != world_size / 2 - 1: game_complete = game_complete or not move(East) if game_complete: break game_complete = game_complete or not move_to_row(0, False) game_complete = game_complete or not move_to_col(0,) if game_complete: break change_hat(Hats.Straw_Hat)

ALL_DIRECTIONS = [North, South, East, West] def opposite_direction(direction): if direction == North: return South elif direction == East: return West elif direction == South: return North elif direction == West: return East def explore_option_iterative(start_direction): global ALL_DIRECTIONS if not move(start_direction): return False path_stack = [(start_direction, 0)] while path_stack and num_items(Items.Gold) < 9863168000000: if get_entity_type() == Entities.Treasure: harvest() start_maze() return True last_move_direction, next_dir_index = path_stack[-1] while next_dir_index < len(ALL_DIRECTIONS): explore_direction = ALL_DIRECTIONS[next_dir_index] path_stack[-1] = (last_move_direction, next_dir_index + 1) if opposite_direction(explore_direction) != last_move_direction: if move(explore_direction): path_stack.append((explore_direction, 0)) break next_dir_index += 1 if next_dir_index == len(ALL_DIRECTIONS): path_stack.pop() move(opposite_direction(last_move_direction)) move(opposite_direction(start_direction)) return False def start_maze(): plant(Entities.Bush) substance = get_world_size() * 2**(num_unlocked(Unlocks.Mazes) - 1) use_item(Items.Weird_Substance, substance) def search(): global drone_id global ALL_DIRECTIONS for _ in range(drone_id): do_a_flip() if drone_id % 2: ALL_DIRECTIONS = ALL_DIRECTIONS[::-1] if drone_id % 3: ALL_DIRECTIONS[0], ALL_DIRECTIONS[1] = (ALL_DIRECTIONS[1], ALL_DIRECTIONS[0]) if drone_id % 5: ALL_DIRECTIONS[1], ALL_DIRECTIONS[3] = (ALL_DIRECTIONS[3], ALL_DIRECTIONS[1]) while True: for direction in ALL_DIRECTIONS: if explore_option_iterative(direction): break drone_id = 0 start_maze() for i in range(max_drones()): drone_id = i spawn_drone(search) drone_id = 0 search()

def generate_maze(): plant(Entities.Bush) substance = get_world_size() * 2**(num_unlocked(Unlocks.Mazes) - 1) use_item(Items.Weird_Substance, substance) def maze(): while True: if num_drones() == 25: if get_entity_type() == Entities.Treasure: harvest() generate_maze() clear() set_world_size(5) list = [] while num_drones() < 26: pos_x = get_pos_x() pos_y = get_pos_y() current = (pos_x, pos_y) if current not in list: list.append(current) spawn_drone(maze) move(North) else: move(East)