commit 9ccebf4eaee71d8892c77a17cff455a9c48d0012
Author: Josh Creek <8179928+jcreek@users.noreply.github.com>
Date:   Tue Dec 23 15:05:58 2025 +0000

    feat(*): Add main file and builtins

diff --git a/__builtins__.py b/__builtins__.py
new file mode 100755
index 0000000..e603140
--- /dev/null
+++ b/__builtins__.py
@@ -0,0 +1,1307 @@
+# This file gives Python type definitions to TFWR builtins to allow editing code with Python editors.
+# Note that the games language is not Python and these definitions are only an approximation.
+# Contributed by @Noon, @KlingonDragon, @dieckie and @Flekay on the TFWR Discord server.
+
+from typing import Any, Optional, Iterable, Tuple, Dict
+from builtins import type, bool, int, float, str, list, set, dict
+
+
+# -------------------------------------------------------------------------------
+class Item:
+    """A member of the Items Class"""
+
+
+class Items:
+    Bone: Item
+    """The bones of an ancient creature."""
+
+    Cactus: Item
+    """Obtained by harvesting sorted cacti."""
+
+    Carrot: Item
+    """Obtained by harvesting carrots."""
+
+    Fertilizer: Item
+    """Call `use_item(Items.Fertilizer)` to instantly remove 2s from the plants remaining grow time."""
+
+    Gold: Item
+    """Found in treasure chests in mazes."""
+
+    Hay: Item
+    """Obtained by cutting grass."""
+
+    Piggy: Item
+    """This item has been removed from the game but remains as a nostalgia trophy."""
+
+    Power: Item
+    """Obtained by harvesting sunflowers. The drone automatically uses this to move twice as fast."""
+
+    Pumpkin: Item
+    """Obtained by harvesting pumpkins."""
+
+    Water: Item
+    """Used to water the ground by calling `use_item(Items.Water)`."""
+
+    Weird_Substance: Item
+    """Call `use_item(Items.Weird_Substance)` on a bush to grow a maze, or on other plants to toggle their infection status."""
+
+    Wood: Item
+    """Obtained from bushes and trees."""
+
+
+# -------------------------------------------------------------------------------
+class Hat:
+    """A member of the Hats class"""
+
+class Hats:
+    Brown_Hat: Hat
+    """A brown hat."""
+
+    Cactus_Hat: Hat
+    """A hat shaped like a cactus."""
+
+    Carrot_Hat: Hat
+    """A hat shaped like a carrot."""
+
+    Dinosaur_Hat: Hat
+    """Equip it to start the dinosaur game."""
+
+    Gold_Hat: Hat
+    """A golden hat."""
+
+    Gold_Trophy_Hat: Hat
+    """A golden trophy hat."""
+
+    Golden_Cactus_Hat: Hat
+    """A golden hat shaped like a cactus."""
+
+    Golden_Carrot_Hat: Hat
+    """A golden hat shaped like a carrot."""
+
+    Golden_Gold_Hat: Hat
+    """A golden version of the gold hat."""
+
+    Golden_Pumpkin_Hat: Hat
+    """A golden hat shaped like a pumpkin."""
+
+    Golden_Sunflower_Hat: Hat
+    """A golden hat shaped like a sunflower."""
+
+    Golden_Tree_Hat: Hat
+    """A golden hat shaped like a tree."""
+
+    Gray_Hat: Hat
+    """A gray hat."""
+
+    Green_Hat: Hat
+    """A green hat."""
+
+    Pumpkin_Hat: Hat
+    """A hat shaped like a pumpkin."""
+
+    Purple_Hat: Hat
+    """A purple hat."""
+
+    Silver_Trophy_Hat: Hat
+    """A silver trophy hat."""
+
+    Straw_Hat: Hat
+    """The default hat."""
+
+    Sunflower_Hat: Hat
+    """A hat shaped like a sunflower."""
+
+    The_Farmers_Remains: Hat
+    """The remains of the farmer."""
+
+    Top_Hat: Hat
+    """A fancy top hat."""
+
+    Traffic_Cone: Hat
+    """A traffic cone hat."""
+
+    Traffic_Cone_Stack: Hat
+    """A stack of traffic cones as a hat."""
+
+    Tree_Hat: Hat
+    """A hat shaped like a tree."""
+
+    Wizard_Hat: Hat
+    """A magical wizard hat."""
+
+    Wood_Trophy_Hat: Hat
+    """A wooden trophy hat."""
+
+# -------------------------------------------------------------------------------
+class Leaderboard:
+    """A member of the Leaderboards class"""
+
+class Leaderboards:
+    Cactus: Leaderboard
+    """Farm 33554432 cacti with multiple drones."""
+
+    Cactus_Single: Leaderboard
+    """Farm 131072 cacti with a single drone on an 8x8 farm."""
+
+    Carrots: Leaderboard
+    """Farm 2000000000 carrots with multiple drones."""
+
+    Carrots_Single: Leaderboard
+    """Farm 100000000 carrots with a single drone on an 8x8 farm."""
+
+    Dinosaur: Leaderboard
+    """Farm 33488928 bones with multiple drones."""
+
+    Fastest_Reset: Leaderboard
+    """The most prestigious category. Completely automate the game from a single farm plot to unlocking the leaderboards again."""
+
+    Hay: Leaderboard
+    """Farm 2 000 000 hay with multiple drones."""
+
+    Hay_Single: Leaderboard
+    """Farm 10 000 000 hay with a single drone on an 8x8 farm."""
+
+    Maze: Leaderboard
+    """Farm 9 863 168 gold with multiple drones."""
+
+    Maze_Single: Leaderboard
+    """Farm 616 448 gold with a single drone on an 8x8 farm."""
+
+    Pumpkins: Leaderboard
+    """Farm 2 000 000 pumpkins with multiple drones."""
+
+    Pumpkins_Single: Leaderboard
+    """Farm 1 000 000 pumpkins with a single drone on an 8x8 farm."""
+
+    Sunflowers: Leaderboard
+    """Farm 10 000 power with multiple drones."""
+
+    Sunflowers_Single: Leaderboard
+    """Farm 10 000 power with a single drone on an 8x8 farm."""
+
+    Wood: Leaderboard
+    """Farm 10 000 000 000 wood with multiple drones."""
+
+    Wood_Single: Leaderboard
+    """Farm 500 000 000 wood with a single drone on an 8x8 farm."""
+
+# -------------------------------------------------------------------------------
+class Entity:
+    """A member of the Entities Class"""
+
+class Entities:
+    Apple: Entity
+    """Dinosaurs love them apparently."""
+
+    Bush: Entity
+    """
+    A small bush that drops `Items.Wood`.
+
+    Average seconds to grow: 4
+    Grows on: grassland or soil
+    """
+
+    Cactus: Entity
+    """
+    Cacti come in 10 different sizes (0-9). When harvested, adjacent cacti that are in sorted order will also be harvested recursively.
+    You receive cactus equal to the number of harvested cacti squared.
+
+    Average seconds to grow: 1
+    Grows on: soil
+    """
+
+    Carrot: Entity
+    """
+    Carrots!
+
+    Average seconds to grow: 6
+    Grows on: soil
+    """
+
+    Dead_Pumpkin: Entity
+    """
+    One in five pumpkins dies when it grows up, leaving behind a dead pumpkin. Dead pumpkins are useless and disappear when something new is planted.
+    `can_harvest()` always returns `False` on dead pumpkins.
+    """
+
+    Dinosaur: Entity
+    """
+    A piece of the tail of the dinosaur hat. When wearing the dinosaur hat, the tail is dragged behind the drone filling previously moved tiles.
+
+    Average seconds to grow: 0.2
+    Grows on: grassland or soil
+    """
+
+    Grass: Entity
+    """
+    Grows automatically on grassland. Harvest it to obtain `Items.Hay`.
+
+    Average seconds to grow: 0.5
+    Grows on: grassland or soil
+    """
+
+    Hedge: Entity
+    """Part of the maze."""
+
+    Pumpkin: Entity
+    """
+    Pumpkins grow together when they are next to other fully grown pumpkins. About 1 in 5 pumpkins dies when it grows up.
+    When you harvest a pumpkin you get `Items.Pumpkin` equal to the number of pumpkins in the mega pumpkin cubed.
+
+    Average seconds to grow: 2
+    Grows on: soil
+    """
+
+    Sunflower: Entity
+    """
+    Sunflowers collect the power from the sun. Harvesting them will give you `Items.Power`.
+    If you harvest a sunflower with the maximum number of petals (and there are at least 10 sunflowers) you get 5x bonus power.
+
+    Average seconds to grow: 5
+    Grows on: soil
+    """
+
+    Treasure: Entity
+    """A treasure that contains gold equal to the side length of the maze in which it is hidden. It can be harvested like a plant."""
+
+    Tree: Entity
+    """
+    Trees drop more wood than bushes. They take longer to grow if other trees grow next to them.
+
+    Average seconds to grow: 7
+    Grows on: grassland or soil
+    """
+
+
+# -------------------------------------------------------------------------------
+class Ground:
+    """A member of the Grounds Class"""
+
+
+class Grounds:
+    Grassland: Ground
+    """The default ground. Grass will automatically grow on it."""
+
+    Soil: Ground
+    """Calling `till()` turns the ground into this. Calling `till()` again changes it back to grassland."""
+
+
+# -------------------------------------------------------------------------------
+class Unlock:
+    """A member of the Unlocks Class"""
+
+
+class Unlocks:
+    Auto_Unlock: Unlock
+    """Automatically unlock things."""
+
+    Cactus: Unlock
+    """
+    Unlock: Cactus!
+    Upgrade: Increases the yield and cost of cactus.
+    """
+
+    Carrots: Unlock
+    """
+    Unlock: Till the soil and plant carrots.
+    Upgrade: Increases the yield and cost of carrots.
+    """
+
+    Costs: Unlock
+    """Allows access to the cost of things."""
+
+    Debug: Unlock
+    """Tools to help with debugging programs."""
+
+    Debug_2: Unlock
+    """Functions to temporarily slow down the execution and make the grid smaller."""
+
+    Dictionaries: Unlock
+    """Get access to dictionaries and sets."""
+
+    Dinosaurs: Unlock
+    """
+    Unlock: Majestic ancient creatures.
+    Upgrade: Increases the yield and cost of dinosaurs.
+    """
+
+    Expand: Unlock
+    """
+    Unlock: Expands the farm land and unlocks movement.
+    Upgrade: Expands the farm. This also clears the farm.
+    """
+
+    Fertilizer: Unlock
+    """Reduces the remaining growing time of the plant under the drone by 2 seconds."""
+
+    Functions: Unlock
+    """Define your own functions."""
+
+    Grass: Unlock
+    """Increases the yield of grass."""
+
+    Hats: Unlock
+    """Unlocks new hat colors for your drone."""
+
+    Import: Unlock
+    """Import code from other files."""
+
+    Leaderboard: Unlock
+    """Join the leaderboard for the fastest reset time."""
+
+    Lists: Unlock
+    """Use lists to store lots of values."""
+
+    Loops: Unlock
+    """Unlocks a simple while loop."""
+
+    Mazes: Unlock
+    """
+    Unlock: A maze with a treasure in the middle.
+    Upgrade: Increases the gold in treasure chests.
+    """
+
+    Megafarm: Unlock
+    """Unlocks multiple drones and drone management functions."""
+
+    Operators: Unlock
+    """Arithmetic, comparison and logic operators."""
+
+    Plant: Unlock
+    """Unlocks planting."""
+
+    Polyculture: Unlock
+    """Use companion planting to increase the yield."""
+
+    Pumpkins: Unlock
+    """
+    Unlock: Pumpkins!
+    Upgrade: Increases the yield and cost of pumpkins.
+    """
+
+    Senses: Unlock
+    """The drone can see what's under it and where it is."""
+
+    Simulation: Unlock
+    """Unlocks simulation functions for testing and optimization."""
+
+    Speed: Unlock
+    """Increases the speed of the drone."""
+
+    Sunflowers: Unlock
+    """
+    Unlock: Sunflowers and Power.
+    Upgrade: Increases the power gained from sunflowers.
+    """
+
+    The_Farmers_Remains: Unlock
+    """Unlocks the special hat 'The Farmers Remains'."""
+
+    Timing: Unlock
+    """Functions to help measure performance."""
+
+    Top_Hat: Unlock
+    """Unlocks the fancy Top Hat."""
+
+    Trees: Unlock
+    """
+    Unlock: Unlocks trees.
+    Upgrade: Increases the yield of bushes and trees.
+    """
+
+    Utilities: Unlock
+    """Unlocks the `min()`, `max()` and `abs()` functions."""
+
+    Variables: Unlock
+    """Assign values to variables."""
+
+    Watering: Unlock
+    """Water the plants to make them grow faster."""
+
+
+# -------------------------------------------------------------------------------
+class Direction:
+    """
+    A direction, e.g. North.
+    """
+
+
+North = Direction()
+"""
+The direction north, i.e. up.
+"""
+
+East = Direction()
+"""
+The direction east, i.e. right.
+"""
+South = Direction()
+"""
+The direction south, i.e. down.
+"""
+West = Direction()
+"""
+The direction west, i.e. left.
+"""
+
+
+# -------------------------------------------------------------------------------
+def harvest() -> bool:
+    """
+    Harvests the entity under the drone.
+    If you harvest an entity that can't be harvested, it will be destroyed.
+
+    returns `True` if an entity was removed, `False` otherwise.
+
+    takes `200` ticks to execute if an entity was removed, `1` tick otherwise.
+
+    example usage:
+    ```
+    harvest()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def can_harvest() -> bool:
+    """
+    Used to find out if plants are fully grown.
+
+    returns `True` if there is an entity under the drone that is ready to be harvested, `False` otherwise.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    if can_harvest():
+        harvest()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def plant(entity: Entity) -> bool:
+    """
+    Spends the cost of the specified `entity` and plants it under the drone.
+    It fails if you can't afford the plant, the ground type is wrong or there's already a plant there.
+
+    returns `True` if it succeeded, `False` otherwise.
+
+    takes `200` ticks to execute if it succeeded, `1` tick otherwise.
+
+    example usage:
+    ```
+    plant(Entities.Bush)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def move(direction: Direction) -> bool:
+    """
+    Moves the drone into the specified `direction` by one tile.
+    If the drone moves over the edge of the farm it wraps back to the other side of the farm.
+
+    - `East `  =  right
+    - `West `  =  left
+    - `North`  =  up
+    - `South`  =  down
+
+    returns `True` if the drone has moved, `False` otherwise.
+
+    takes `200` ticks to execute if the drone has moved, `1` tick otherwise.
+
+    example usage:
+    ```
+    move(North)
+    ```
+    """
+    ...
+
+# -------------------------------------------------------------------------------
+def can_move(direction: Direction) -> bool:
+    """
+    Checks if the drone can move in the specified `direction`.
+
+    returns `True` if the drone can move, `False` otherwise.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    if can_move(North):
+        move(North)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def swap(direction: Direction) -> bool:
+    """
+    Swaps the entity under the drone with the entity next to the drone in the specified `direction`.
+    - Doesn't work on all entities.
+    - Also works if one (or both) of the entities are `None`.
+
+    returns `True` if it succeeded, `False` otherwise.
+
+    takes `200` ticks to execute on success, `1` tick otherwise.
+
+    example usage:
+    ```
+    swap(North)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def till() -> None:
+    """
+    Tills the ground under the drone into soil. If it's already soil it will change the ground back to grassland.
+
+    returns `None`
+
+    takes `200` ticks to execute.
+
+    example usage:
+    ```
+    till()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_pos_x() -> int:
+    """
+    Gets the current x position of the drone.
+    The x position starts at `0` in the `West` and increases in the `East` direction.
+
+    returns a number representing the current x coordinate of the drone.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    x, y = get_pos_x(), get_pos_y()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_pos_y() -> int:
+    """
+    Gets the current y position of the drone.
+    The y position starts at `0` in the `South` and increases in the `North` direction.
+
+    returns a number representing the current y coordinate of the drone.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    x, y = get_pos_x(), get_pos_y()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_world_size() -> int:
+    """
+    Get the current size of the farm.
+
+    returns the side length of the grid in the north to south direction.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    for i in range(get_world_size()):
+        move(North)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_entity_type() -> Entity | None:
+    """
+    Find out what kind of entity is under the drone.
+
+    returns `None` if the tile is empty, otherwise returns the type of the entity under the drone.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    if get_entity_type() == Entities.Grass:
+        harvest()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_ground_type() -> Ground:
+    """
+    Find out what kind of ground is under the drone.
+
+    returns the type of the ground under the drone.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    if get_ground_type() != Grounds.Soil:
+        till()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_time() -> float:
+    """
+    Get the current game time.
+
+    returns the time in seconds since the start of the game.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    start = get_time()
+
+    do_something()
+
+    time_passed = get_time() - start
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_tick_count() -> int:
+    """
+    Used to measure the number of ticks performed.
+
+    returns the number of ticks performed since the start of execution.
+
+    takes `0` tick to execute.
+
+    example usage:
+    ```
+    do_something()
+
+    print(get_tick_count())
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def use_item(item: Item, n: int = 1) -> bool:
+    """
+    Attempts to use the specified `item` `n` times. Can only be used with some items including `Items.Water`, `Items.Fertilizer` and `Items.Weird_Substance`.
+
+    returns `True` if an item was used, `False` if the item can't be used or you don't have enough.
+
+    takes `200` ticks to execute if it succeeded, `1` tick otherwise.
+
+    example usage:
+    ```
+    if use_item(Items.Fertilizer):
+        print("Fertilizer used successfully")
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_water() -> float:
+    """
+    Get the current water level under the drone.
+
+    returns the water level under the drone as a number between `0` and `1`.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    if get_water() < 0.5:
+        use_item(Items.Water)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def do_a_flip() -> None:
+    """
+    Makes the drone do a flip! This action is not affected by speed upgrades.
+
+    returns `None`
+
+    takes 1s to execute.
+
+    example usage:
+    ```
+    while True:
+        do_a_flip()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def pet_the_piggy() -> None:
+    """
+    Pets the piggy! This action is not affected by speed upgrades.
+
+    returns `None`
+
+    takes 1s to execute.
+
+    example usage:
+    ```
+    while True:
+        pet_the_piggy()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def print(*something: Any) -> None:
+    """
+    Prints `something` into the air above the drone using smoke. This action is not affected by speed upgrades.
+    Multiple values can be printed at once.
+
+    returns `None`
+
+    takes 1s to execute.
+
+    example usage:
+    ```
+    print('ground:', get_ground_type())
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def set_execution_speed(speed: float) -> None:
+    """
+    Limits the speed at which the program is executed to better see what's happening.
+
+    - A `speed` of `1` is the speed the drone has without any speed upgrades.
+    - A `speed` of `10` makes the code execute `10` times faster and corresponds to the speed of the drone after `9` speed upgrades.
+    - A `speed` of `0.5` makes the code execute at half of the speed without speed upgrades. This can be useful to see what the code is doing.
+
+    If `speed` is faster than the execution can currently go it will just go at max speed.
+
+    If `speed` is `0` or negative, the speed is changed back to max speed.
+     The effect will also stop when the execution stops.
+
+    returns `None`
+
+    takes `200` ticks to execute.
+
+    example usage:
+    ```
+    set_execution_speed(1)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def set_world_size(size: float) -> None:
+    """
+    Limits the size of the farm to better see what's happening.
+    Also clears the farm and resets the drone position.
+    - Sets the farm to a `size` x `size` grid.
+    - The smallest `size` possible is `3`.
+    - A `size` smaller than `3` will change the grid back to its full size.
+    - The effect will also stop when the execution stops.
+
+    returns `None`
+
+    takes `200` ticks to execute.
+
+    example usage:
+    ```
+    set_world_size(5)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def num_items(item: Item) -> float:
+    """
+    Find out how much of `item` you currently have.
+
+    returns the number of `item` currently in your inventory.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    if num_items(Items.Fertilizer) > 0:
+        use_item(Items.Fertilizer)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_cost(thing: Entity | Item | Unlock, level: Optional[int] = None) -> Dict[Item, float] | None:
+    """
+    Gets the cost of a `thing`
+
+    If `thing` is an entity: get the cost of planting it.
+    If `thing` is an unlock: get the cost of unlocking it at the specified level.
+
+    - returns a dictionary with items as keys and numbers as values. Each item is mapped to how much of it is needed.
+    - returns `None` for unlocks that are already unlocked (when no level specified).
+    - The optional `level` parameter specifies the upgrade level for unlocks.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    cost = get_cost(Unlocks.Carrots)
+    for item in cost:
+        if num_items(item) < cost[item]:
+            print('not enough items to unlock carrots')
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def clear() -> None:
+    """
+    Removes everything from the farm, moves the drone back to position `(0,0)` and changes the hat back to the default.
+
+    returns `None`
+
+    takes `200` ticks to execute.
+
+    example usage:
+    ```
+    clear()
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def get_companion() -> Tuple[Entity, Tuple[int, int]] | None:
+    """
+    Get the companion preference of the plant under the drone.
+
+    returns a tuple of the form `(companion_type, (companion_x_position, companion_y_position))` or `None` if there is no companion.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    companion = get_companion()
+    if companion != None:
+        plant_type, (x, y) = companion
+        print("Companion:", plant_type, "at", x, ",", y)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def unlock(unlock: Unlock) -> bool:
+    """
+    Has exactly the same effect as clicking the button corresponding to `unlock` in the research tree.
+
+    returns `True` if the unlock was successful, `False` otherwise.
+
+    takes `200` ticks to execute if it succeeded, `1` tick otherwise.
+
+    example usage:
+    ```
+    unlock(Unlocks.Carrots)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def num_unlocked(thing: Unlock | Entity | Ground | Item) -> int:
+    """
+    Used to check if an unlock, entity, ground, item or hat is already unlocked.
+
+    returns `1` plus the number of times `thing` has been upgraded if `thing` is upgradable. Otherwise returns `1` if `thing` is unlocked, `0` otherwise.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    if num_unlocked(Unlocks.Carrots) > 0:
+        plant(Entities.Carrot)
+    else:
+        print("Carrots not unlocked yet")
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def measure(direction: Optional[Direction] = None) -> float | Tuple[int, int] | None:
+    """
+    Can measure some values on some entities. The effect of this depends on the entity.
+
+    overloads:
+    `measure()`: measures the entity under the drone.
+    `measure(direction)`: measures the neighboring entity in the `direction` of the drone.
+
+    Sunflower: returns the number of petals.
+    Maze: returns the position of the current treasure from anywhere in the maze.
+    Cactus: returns the size.
+    Dinosaur: returns the number corresponding to the type.
+    All other entities: returns `None`.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    num_petals = measure()
+    treasure_pos = measure()  # Works anywhere in maze
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def leaderboard_run(leaderboard: Leaderboard, file_name: str, speedup: float) -> None:
+    """
+    Starts a timed run for the `leaderboard` using the specified `file_name` as a starting point.
+    `speedup` sets the starting speedup.
+
+    returns `None`
+
+    takes `200` ticks to execute.
+
+    example usage:
+    ```
+    leaderboard_run(Leaderboards.Fastest_Reset, "full_run", 256)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def simulate(filename: str, sim_unlocks: Dict[Unlocks, float] | Iterable[Unlocks] | type[Unlocks], sim_items: Dict[Item, float], sim_globals: Dict[str, Any], seed: float, speedup: float) -> float:
+    """
+    Starts a simulation for the leaderboard using the specified `file_name` as a starting point.
+
+    `sim_unlocks`: A sequence containing the starting unlocks.
+
+    `sim_items`: A dict mapping items to amounts. The simulation starts with these items.
+
+    `sim_globals`: A dict mapping variable names to values. The simulation starts with these variables in the global scope.
+
+    `seed`: The random seed of the simulation. Must be a positive integer.
+
+    `speedup`: The starting speedup.
+
+    returns the time it took to run the simulation.
+
+    takes `200` ticks to execute.
+
+    example usage:
+
+    ```
+    filename = "f1"
+    sim_unlocks = Unlocks
+    sim_items = {Items.Carrot : 10000, Items.Hay : 50}
+    sim_globals = {"a" : 13}
+    seed = 0
+    speedup = 64
+    run_time = simulate(filename, sim_unlocks, sim_items, sim_globals, seed, speedup)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def quick_print(*something: Any) -> None:
+    """
+    Prints a value just like `print()` but it doesn't stop to write it into the air so it can only be found on the output page.
+
+    returns `None`
+
+    takes `0` ticks to execute.
+
+    example usage:
+    ```
+    quick_print('hi mom')
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def random() -> float:
+    """
+    Samples a random number between 0 (inclusive) and 1 (exclusive).
+
+    returns the random number.
+
+    takes `1` ticks to execute.
+
+    example usage:
+    ```
+    def random_elem(list):
+        index = random() * len(list) // 1
+        return list[index]
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def len(obj):
+    """
+    Returns the number of items in an object.
+
+    returns the length of the object.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    my_list = [1, 2, 3]
+    length = len(my_list)  # 3
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def range(start, stop=None, step=1):
+    """
+    Returns a sequence of numbers from start (inclusive) to stop (exclusive).
+
+    returns a range object.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    for i in range(5):
+        print(i)  # 0, 1, 2, 3, 4
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def str(obj: Any) -> str:
+    """
+    Converts an object to its string representation.
+
+    returns the string representation of the object.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    string = str(1000)
+    print(string)  # prints "1000"
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def min(*args: Any) -> Any:
+    """
+    Gets the minimum of a sequence of elements or several passed arguments.
+    Can be used on numbers and strings.
+
+    `min(a,b,c)`: Returns the minimum of `a`, `b` and `c`.
+    `min(sequence)`: Returns the minimum of all values in a sequence.
+
+    returns the minimum value from the arguments.
+
+    takes #comparisons ticks to execute.
+
+    example usage:
+    ```
+    smallest = min(1, 5, 3, 2)
+    smallest_from_list = min([3, 6, 34, 16])
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def max(*args: Any) -> Any:
+    """
+    Gets the maximum of a sequence of elements or several passed arguments.
+    Can be used on numbers and strings.
+
+    `max(a,b,c)`: Returns the maximum of `a`, `b` and `c`.
+    `max(sequence)`: Returns the maximum of all values in a sequence.
+
+    returns the maximum value from the arguments.
+
+    takes #comparisons ticks to execute.
+
+    example usage:
+    ```
+    largest = max(1, 5, 3, 2)
+    largest_from_list = max([3, 6, 34, 16])
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def abs(x: float) -> float:
+    """
+    Returns the absolute value of a number.
+
+    returns the absolute value of x.
+
+    takes `1` tick to execute.
+
+    example usage:
+    ```
+    positive = abs(-5)
+    print(positive)  # prints 5
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def change_hat(hat: Hat) -> None:
+    """
+    Changes the hat of the drone to the specified `hat`.
+
+    returns `None`
+
+    takes `200` ticks to execute.
+
+    example usage:
+    ```
+    change_hat(Hats.Dinosaur_Hat)
+    ```
+    ...
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def spawn_drone(function: str) -> Any:
+    """
+    Spawns a new drone in the same position as the drone that ran the `spawn_drone(function)` command. The new drone then begins executing the specified function. After it is done, it will disappear automatically.
+
+    returns the handle of the new drone or `None` if all drones are already spawned.
+
+    takes `200` ticks to execute if a drone was spawned, `1` otherwise.
+
+    example:
+    ```
+    def harvest_column():
+        for _ in range(get_world_size()):
+            harvest()
+            move(North)
+
+    while True:
+        if spawn_drone(harvest_column):
+            move(East)
+    ```
+    """
+    ...
+
+
+# -------------------------------------------------------------------------------
+def wait_for(drone: Any) -> Any:
+    """
+    Waits until the given drone terminates.
+
+    returns the return value of the function that the drone was running.
+
+    takes `1` tick to execute if the awaited drone is already done.
+
+    example:
+    ```
+    def get_entity_type_in_direction(dir):
+        move(dir)
+        return get_entity_type()
+
+    def zero_arg_wrapper():
+        return get_entity_type_in_direction(North)
+    handle = spawn_drone(zero_arg_wrapper)
+    print(wait_for(handle))
+    ```
+    """
+    ...
+
+# -------------------------------------------------------------------------------
+def has_finished(drone: Any) -> Any:
+    """
+    Checks if the given drone has finished.
+
+    returns `True` if the drone has finished, `False` otherwise.
+
+    takes `1` tick to execute.
+
+    example:
+    ```
+    drone = spawn_drone(function)
+    while not has_finished(drone):
+        do_something_else()
+    result = wait_for(drone)
+    ```
+    """
+    ...
+
+# -------------------------------------------------------------------------------
+def max_drones() -> int:
+    """
+    returns the maximum number of drones that you can have in the farm.
+
+    takes `1` tick to execute.
+
+    example:
+    ```
+    while num_drones() < max_drones():
+        spawn_drone("some_file_name")
+        move(East)
+    ```
+    """
+    ...
+
+# -------------------------------------------------------------------------------
+def num_drones() -> int:
+    """
+    returns the number of drones currently in the farm.
+
+    takes `1` tick to execute.
+
+    example:
+    ```
+    while num_drones() < max_drones():
+        spawn_drone("some_file_name")
+        move(East)
+    ```
+    """
+    ...
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..4697fb5
--- /dev/null
+++ b/main.py
@@ -0,0 +1,38 @@
+import hay
+import wood
+import carrots
+import pumpkins
+import sunflowers
+import cacti
+
+sunflowers_array = {} # sunflowers_array[(x, y)] = petals
+cactus_array = {} # cactus_array[(x, y)] = size
+
+num_loops = 10
+
+def run_loop(number_of_loops, label, fn):
+    clear()
+    for i in range(number_of_loops):
+        # print(label, i+1)
+        fn()
+
+def harvest_sunflowers_wrapper():
+    # this wrapper function is needed as the game doesn't support llambdas,
+    # which are needed as we're passing an argument into the function
+    sunflowers.harvest_sunflowers(sunflowers_array)
+
+def harvest_cacti_wrapper():
+    # this wrapper function is needed as the game doesn't support llambdas,
+    # which are needed as we're passing an argument into the function
+    cacti.harvest_cacti(cactus_array)
+
+clear()
+
+while True:
+    run_loop(num_loops, 'hay', hay.harvest_hay)
+    run_loop(num_loops, 'wood', wood.harvest_wood)
+    run_loop(num_loops * 20, 'carrots', carrots.harvest_carrots)
+    run_loop(num_loops, 'pumpkins', pumpkins.harvest_pumpkins)
+    sunflowers.initial_planting_performed = False
+    run_loop(num_loops * 50, 'sunflowers', harvest_sunflowers_wrapper)
+    run_loop(1, 'cacti', harvest_cacti_wrapper)