Steam Community guide by Luzahe.

Intro

Most of the codes below were not written by me. I just modified/improved them (except for 1-2, which I didn't touch at all). I just did a lot of research throughout my epic journey on The Farmer Was Replaced (Discord, YouTube, Web, Steam, AI). I don't take credit for the codes below, even though I spent time on them. But I'm sharing them with you in the hope that they will help you as much as they helped me.
I can't credit each script to each person because I picked them up from all over the place, but if you're sure one of yours is there, let me know and I'll mention you.

Hay

hay farm with polyculture and multiple drones
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()Or hay farm with only one drone (for leaderboard maybe)
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)

Wood

Wood farm with polyculture and multiple drones
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()and wood farm with polyculture and only one drone
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)

Carrots

Farm with polyculture and multiple drones
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()
** Just a mix between woods and carrots**
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()

Sunflowers

Replaces the previous code to unlock the "Sunflower master" achievement.
clear()
def harvest_column():
while True:
if get_pos_y() != 0:
move_to(get_pos_x(), 0)
for _ in range(get_world_size()):
if get_ground_type() != Grounds.Soil:
till()
if get_water() < 0.75:
use_item(Items.Water)
if can_harvest():
harvest()
if get_entity_type() == None:
plant(Entities.Sunflower)
move(North)
def main_loop():
world_size = get_world_size()
for i in range(world_size - 1):
if spawn_drone(harvest_column):
move(East)
harvest_column()
while True:
main_loop()

Pumpkins

There is certainly room for improvement, but it does the job.
This code is not sufficient to achieve 20M in 1 minute, but there are now other players who have shared their excellent codes for this, so I invite you to visit them if you need to!
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)But you can try this code for the pumpkin achievement.
Submitted by Arthradax in the comments section ! (Thanks!)
clear()
change_hat(Hats.Brown_Hat)
world_size = get_world_size()
needs_till=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 till_column():
for _ in range(world_size):
till()
move(North)
def plant_first_batch():
for _ in range(world_size):
plant(Entities.Pumpkin)
move(North)
def plant_nth_batch():
for _ in range(world_size):
while not can_harvest():
if get_entity_type() == Entities.Dead_Pumpkin:
plant(Entities.Pumpkin)
use_item(Items.Fertilizer)
move(North)
def check_done():
return measure()==measure(South)
def drone_plant_loop():
if needs_till:
till_column()
plant_first_batch()
while not check_done():
plant_nth_batch()
def plant_pumpkins():
for _ in range(world_size-1):
spawn_drone(drone_plant_loop)
move(East)
drone_plant_loop()
while num_drones()>1:
pass
harvest()
move(East)
while True:
plant_pumpkins()
needs_till=False

Cactus

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()For the "Wrong Order" achievement
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()

Dino

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