Steam Community guide by v70I.

I want to say something

First of all im not a native speaker so im sorry if there are any spelling or grammar mistakes.
Second of all NOT all of the codes below are self written. A lot of them are copied from other websites and sometimes modified to fit the conditions. I do not know anymore where they came from but i wanted to share working code for every or nearly every Achievement in the game.
Important:
These codes are most likely not working in the early stages of the game.
So far i can tell that you need to unlock at least 32 Drones; Polyculture; 32x32 Farmsize; Basic math stuff; funktions; Import
maybe im missing something

Hello World; Infinityloop; Error; Acrobat; Stylish

For every one that managed to skip the inevitable Achievemnts:
while True:
pet_the_piggy()
do_a_flip()
change_hat(Hats.Brown_Hat)
Make_Error()

Hay

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()

Carrots

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()

Wood

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)
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()

Sunflower

clear()
change_hat(Hats.Purple_Hat)
def Sunflower():
def harvestColum():
for _ in range(get_world_size()):
if get_ground_type()!=Grounds.Soil:
till()
plant(Entities.Sunflower)
if can_harvest():
harvest()
plant(Entities.Sunflower)
move(North)
else:
move(North)
while num_items(Items.Power)<40000000:
if spawn_drone(harvestColum):
move(East)
Sunflower()

Pumpkin

clear()
change_hat(Hats.Brown_Hat)
set_world_size(32)
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
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)
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)

Cactus

while True:
WORLD_SIZE = get_world_size()
MAX_DRONES = max_drones()
def main():
plant_and_sort_all_rows()
sort_all_columns()
def plant_and_sort_all_rows():
global WORLD_SIZE
for row in range(WORLD_SIZE):
if num_drones() >= WORLD_SIZE:
move_to(0, row)
pas_current_row()
break
move_to(0, row)
drone = spawn_drone(pas_current_row)
move_to(0,1)
while num_drones() > 1:
pass
def pas_current_row():
global WORLD_SIZE
row = get_pos_y()
for col in range(WORLD_SIZE):
move_to(col, row)
till()
plant(Entities.Cactus)
insertion_sort_row_step()
def insertion_sort_row_step():
while get_pos_x() > 0:
if measure() < measure(West):
swap(West)
move(West)
else:
break
def sort_all_columns():
global WORLD_SIZE
global MAX_DRONES
for col in range(WORLD_SIZE):
move_to(col, 1)
while num_drones() >= MAX_DRONES:
sort_current_column()
break
spawn_drone(sort_current_column)
while num_drones() > 1:
pass
def sort_current_column():
global WORLD_SIZE
while get_pos_y() < (WORLD_SIZE - 1):
insertion_sort_column_step()
insertion_sort_column_step()
def insertion_sort_column_step():
if get_pos_y() == 0:
move(North)
return
if measure() < measure(South):
swap(South)
if get_pos_y() > 1:
move(South)
insertion_sort_column_step()
return
move(North)
def move_to(x, y):
global WORLD_SIZE
dx = x - get_pos_x()
dy = y - get_pos_y()
if dx > 0:
if dx > WORLD_SIZE/2:
move(West)
else:
move(East)
elif dx < 0:
if abs(dx) > WORLD_SIZE/2:
move(East)
else:
move(West)
if dy > 0:
if dy > WORLD_SIZE/2:
move(South)
else:
move(North)
elif dy < 0:
if abs(dy) > WORLD_SIZE/2:
move(North)
else:
move(South)
if not (get_pos_x() == x and get_pos_y() == y):
move_to(x, y)
else:
return
if name == "main":
clear()
main()
harvest()

Maze (Recycling&Labyrinthmaster not working)

ALL_DIRECTIONS = [North, South, East, West]
#change map size here ( remove "#" below)
#set_world_size(15)
clear()
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()

For the "Recycling" and "Big Gold Farmer" achievements

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)

Dino

#change worldsize below by removing "#"
#set_world_size(12)
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)

Import Zyklus

You need 2 different code-windows
First window:
def f0():
import ImportzyklusZubehör
ImportzyklusZubehör.f1()
f0()
Second Window:
def f1():
import ImportZyklus
ImportZyklus.f0()
You get the Achievement by running the first code-window

Wrong Order

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)
direction = East
if moves_needed > 0:
pass
else:
direction = West
for _ in range(abs(moves_needed)):
move(direction)
def move_to_y_pos(y_target):
y_curr = get_pos_y()
moves_needed = _shortest_delta(y_curr, y_target)
direction = North
if moves_needed > 0:
pass
else:
direction = South
for _ in range(abs(moves_needed)):
move(direction)
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 _ 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 _ 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()

Left-to-right pass

while x_curr < right:

If the current element is smaller than the next, swap

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()

Right-to-left pass

while x_curr > left:

If the previous element is larger than the current, swap

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()

Bottom-to-top pass

while y_curr < right:

If the current element is smaller than the one above, swap

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()

Top-to-bottom pass

while y_curr > left:

If the element below is larger than the current, swap

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 _ 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 _ 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()

Fashionshow

def newHat():
hats = [Hats.Gold_Hat, Hats.Golden_Cactus_Hat, Hats.Golden_Carrot_Hat, Hats.Golden_Sunflower_Hat, Hats.Golden_Tree_Hat]
while True:
move(North)
change_hat(hats[get_pos_x() % 5])
while True:
spawn_drone(newHat)
move(East)

The Farmer Was Replaced: Most Achievements Codes

Short answer