- name: tree
  display:
    attr: plant
    char: 'T'
  description:
  - |
    A tall, living entity made of a tough cellular material called "wood".
    They regrow after being harvested and are an important raw ingredient used
    in making many different devices.
  properties: [portable, growable]
  growth: [500, 600]

- name: branch
  display:
    attr: wood
    char: 'y'
  description:
  - A branch cut from a tree.  It's as if the tree had to make a decision
    and was exploring two options.
  properties: [portable]

- name: log
  display:
    attr: wood
    char: 'l'
  description:
  - A wooden log, obtained by harvesting a tree and cutting off its branches.
  properties: [portable]

- name: board
  display:
    attr: wood
    char: 'w'
  description:
  - A wooden board, made by cutting a log into pieces.
  properties: [portable]

- name: workbench
  display:
    attr: wood
    char: 'π'
  description:
  - A plain wooden workbench, providing space to make other
    things using the `make` command.
  - 'Example:'
  - 'make "log"'
  properties: [portable]
  capabilities: [make]

- name: paper
  display:
    attr: snow
    char: '■'
  description:
  - A flat material made of pressed and dried wood fibers,
    used as a surface on which to inscribe symbols.
  properties: [portable]

- name: PhD thesis
  display:
    attr: snow
    char: 'P'
  description:
  - Perhaps writing one of these will help gain the trust and respect of
    the native inhabitants.
  properties: [portable]

- name: rock
  display:
    attr: rock
    char: 'o'
  description:
  - A medium-sized rock, picked up from the ground or created by drilling.
    Can be used to build a simple furnace, among other things.
  properties: [portable]

- name: lodestone
  display:
    attr: iron
    char: 'o'
  description:
  - A medium-sized rock... that looks a little different.
    It seems to react to iron and surprisingly also to naturally growing bits.
  properties: [portable]
  capabilities: [negation]

- name: boulder
  display:
    attr: rock
    char: '@'
  description:
  - A very large, impassable rock. A drill can be used to get rid of it and turn it into smaller rocks.
  properties: [unwalkable]

- name: mountain
  display:
    attr: snow
    char: 'A'
  description:
  - A mountain. Can be tunneled through with a drill, but it takes time.
  properties: [unwalkable]

- name: mountain tunnel
  display:
    attr: snow
    char: 'Å'
    priority: 11
  description:
  - A tunnel in a mountain through which robots can freely move.
  properties: []

- name: copper ore
  display:
    attr: copper
    char: 'C'
  description:
  - Raw copper ore, useful for making wires, pipes, and other metal things.
    Patches of copper ore can be found on the surface, but are quickly exhausted.
  - Scanners seem to indicate larger quantities of copper could be found beneath some of the
    mountains, but those would require a drill to access and mine.
  properties: [portable]

- name: copper mine
  display:
    attr: copper'
    char: 'Å'
    priority: 11
  description:
  - A copper vein that can be actively mined to produce copper ore.
  properties: []

- name: copper wire
  display:
    attr: copper
    char: '|'
  description:
  - Copper wire is very good at conducting electricity and useful for
    making various types of circuits and machines.
  properties: [portable]

- name: strange loop
  display:
    attr: copper
    char: '8'
  description:
  - Two copper wires twisted together in a strange shape that loops
    back on itself. It must be useful for something...
  properties: [portable]
  capabilities: [recursion]

- name: copper pipe
  display:
    attr: copper
    char: 'I'
  description:
  - A pipe made out of a thin sheet of copper.  Great for transmitting
    water or steam.
  properties: [portable]

- name: iron plate
  display:
    attr: iron
    char: '■'
  description:
  - Worked iron suitable for crafting resilient tools.
  - It also possess some electro-magnetic properties.
  properties: [portable]

- name: iron gear
  display:
    attr: iron
    char: '*'
  description:
  - An iron gear, suitable for constructing larger, more powerful
    machinery than a wooden gear.
  properties: [portable]

- name: iron ore
  display:
    attr: iron
    char: 'F'
  description:
  - Raw iron ore. Used to create more resilient tools than copper.
  - It can only be mined by drilling in the mountains.
  properties: [portable]

- name: iron mine
  display:
    attr: iron'
    char: 'Å'
    priority: 11
  description:
  - An iron vein that can be actively mined to produce iron ore.
  properties: []

- name: quartz
  display:
    attr: quartz
    char: 'Q'
  description:
  - Raw quartz crystals.  Useful for creating devices like clocks, and
    can be processed to extract silicon.
  - It can only be mined by drilling in the mountains.
  properties: [portable]

- name: quartz mine
  display:
    attr: quartz
    char: 'Å'
    priority: 11
  description:
  - A quartz vein that can be actively mined to produce quartz.
  properties: []

- name: silicon
  display:
    attr: quartz
    char: 'S'
  description:
  - Extracted by processing quartz at high temperatures, silicon can
    be used to construct integrated circuits.
  properties: [portable]

- name: deep mine
  display:
    attr: rock
    char: 'Å'
    priority: 11
  description:
  - A deep mine that yields rare and wonderful treasures to those who are patient.
  - But be careful lest you delve too greedily and too deep.
  properties: []

- name: silver
  display:
    attr: silver
    char: '•'
  description:
  - A shiny, metallic substance, noted for its high reflectivity when polished.
  properties: [portable]

- name: gold
  display:
    attr: gold
    char: '•'
  description:
  - A shiny, metallic substance, with applications in specialized electronics.
  - It also seems to be highly valued by local aliens.
  properties: [portable]

- name: mithril
  display:
    attr: silver
    char: 'M'
  description:
  - Mithril can be beaten like copper, and polished like glass.  One
    can also make of it a metal, light and yet harder than tempered
    steel. Its beauty is like to that of common silver, but the beauty
    of mithril does not tarnish or grow dim.
  properties: [portable]

- name: furnace
  display:
    attr: fire
    char: '#'
  description:
  - A furnace can be used to turn metal ore into various useful products.
  properties: [portable]

- name: big furnace
  display:
    attr: fire
    char: '#'
  description:
  - A big furnace can get even hotter than a normal furnace, and can be used
    to process quartz into silicon.
  properties: [portable]

- name: small motor
  display:
    attr: entity
    char: 'm'
  description:
  - A motor is useful for making devices that can turn when electric
    current is applied.
  - This one is rather small, but surprisingly efficient.
  properties: [portable]

- name: big motor
  display:
    attr: entity
    char: 'M'
  description:
  - A motor is useful for making devices that can turn when electric
    current is applied.
  - This one is huge and could be used to construct powerful machinery.
  properties: [portable]

- name: flower
  display:
    attr: flower
    char: '*'
  description:
  - A beautiful flower that grows wild in local meadows.  It is not clear
    what it might be useful for, but it looks nice.
  properties: [portable, growable]
  growth: [30, 50]

- name: cotton
  display:
    attr: silver
    char: 'i'
  description:
  - A plant with tufts of soft fibers that can be harvested and used
    to make things, including sheets of material that the local
    aliens like to drape over their bodies.
  properties: [portable, growable]
  growth: [100, 800]

- name: string
  display:
    attr: silver
    char: '~'
  description:
  - A long, flexible device for transferring either force or
    information, made of twisted cotton fibers.  Multiple strings can
    also be woven into larger configurations such as cloth or nets.
  - |
    A string device enables two commands: the first, `format : a ->
    text`, can turn any value into a suitable text representation.
    The second is the infix operator `++ : text -> text -> text`
    which can be used to concatenate two text values.  For example,
  - |
    "Number of widgets: " ++ format numWidgets
  properties: [portable]
  capabilities: [text]

- name: lambda
  display:
    attr: flower
    char: 'λ'
  description:
  - A wild lambda.  They are somewhat rare, but regrow when picked.  Lambdas
    are delicious when cooked into curry.
  - Lambdas can also be used to create functions. For example,
  - '  def thrice : cmd unit -> cmd unit = \c. c;c;c end'
  - defines the function `thrice` which repeats a command three times.
  properties: [portable, growable]
  growth: [100, 200]
  capabilities: [lambda]

- name: curry
  display:
    attr: flower
    char: 'C'
  description:
  - Delicious curry cooked from wild lambdas.
  properties: [portable]

- name: water
  display:
    attr: water
    char: ' '
  description:
  - Liquid dihydrogen monoxide, which seems to be plentiful on this planet.
  properties: [portable, infinite, liquid]

- name: wavy water
  display:
    attr: water
    char: '~'
  description:
  - A wavy section of water.  The same as normal water, but with more waves.
  properties: [portable, infinite, liquid]
  yields: water

- name: boat
  display:
    attr: wood
    char: 'B'
  description:
  - A robot with a boat installed can float on top of water without drowning.
  - |
    Note: most devices are automatically installed on robots that
    will require them; but this doesn't work in the case of boats since floating is not
    associated with any particular command.  To manually ensure a boat is installed on
    a robot, just add the special command `require "boat"` to the robot's program.
  properties: [portable]
  capabilities: [float]

- name: sand
  display:
    attr: sand
    char: '█'
  description:
  - A substance composed mostly of tiny rocks and mineral particles.  It
    tends to be found near water, and can be used in a furnace to make glass.
  properties: [portable, infinite]

- name: glass
  display:
    attr: entity
    char: '□'
  description:
  - A pane of a brittle, clear substance, made from melting sand in a furnace.
  properties: [portable]

- name: LaTeX
  display:
    attr: flower
    char: '$'
  description:
  - A naturally occurring substance derived from trees, useful for producing
    rubber and for typesetting mathematical documents.
  properties: [portable, growable]
  growth: [2000, 3000]

- name: rubber
  display:
    attr: rubber
    char: '%'
  description:
  - A flexible, durable material made from LaTeX.
  properties: [portable]

- name: bit (0)
  display:
    attr: entity
    char: '0'
  description:
  - A bit is used to represent the smallest possible amount of information.
    Useful for constructing various information-processing devices, as well as drills.
  properties: [portable, growable]
  growth: [200, 400]

- name: bit (1)
  display:
    attr: entity
    char: '1'
  description:
  - A bit is used to represent the smallest possible amount of information.
    Useful for constructing various information-processing devices, as well as drills.
  properties: [portable, growable]
  growth: [200, 400]

- name: pixel (R)
  display:
    attr: red
    char: '.'
  description:
  - A tiny picture element, used either to emit or detect red light.
  properties: [portable, growable]
  growth: [1000, 1500]

- name: pixel (G)
  display:
    attr: green
    char: '.'
  description:
  - A tiny picture element, used either to emit or detect green light.
  properties: [portable, growable]
  growth: [1000, 1500]

- name: pixel (B)
  display:
    attr: blue
    char: '.'
  description:
  - A tiny picture element, used either to emit or detect blue light.
  properties: [portable, growable]
  growth: [1000, 1500]

- name: camera
  display:
    attr: device
    char: '@'
  description:
  - A camera is a device for capturing images.
  properties: [portable]

- name: circuit
  display:
    attr: plant
    char: '#'
  description:
  - |
    A circuit is needed for constructing various "smart" devices.
  properties: [portable]

- name: drill bit
  display:
    attr: entity
    char: '!'
  description:
  - A drill bit is the most important component of a drill, and must be made
    out of two bits of opposite parity, for strength.
  properties: [portable]

- name: box
  display:
    attr: wood
    char: '□'
  description:
  - A wooden box.  It can hold things or be used as housing for other devices.
  properties: [portable]

- name: wooden gear
  display:
    attr: wood
    char: '*'
  description:
  - A wooden gear.  Not quite as strong or versatile as an iron gear, but easy to produce.
  properties: [portable]

- name: teeter-totter
  display:
    attr: wood
    char: '/'
  description:
  - A rotating board apparently popular with young aliens.  Perhaps it
    could also be used as a primitive balance scale.
  properties: [portable]

- name: Linux
  display:
    attr: entity
    char: 'L'
  description:
  - A copy of the Linux operating system.
  properties: [portable]

- name: gold coin
  display:
    char: '©'
    attr: gold
  description:
    - A small round shaped piece of gold metal that the aliens pass between
      each other occasionaly.
    - Besides staying shiny it does not appear to have practical use.
  properties: [portable]

############################################################
### Utility ################################################
############################################################

- name: upper left corner
  display:
    attr: entity
    char: '┌'
  description:
    - Upper left corner.
  properties: [unwalkable, known]

- name: upper right corner
  display:
    attr: entity
    char: '┐'
  description:
    - An upper right corner wall.
  properties: [unwalkable, known]

- name: lower left corner
  display:
    attr: entity
    char: '└'
  description:
    - A lower left corner wall.
  properties: [unwalkable, known]

- name: lower right corner
  display:
    attr: entity
    char: '┘'
  description:
    - A lower right corner wall.
  properties: [unwalkable, known]

- name: down and horizontal wall
  display:
    attr: entity
    char: '┬'
  description:
    - A down and horizontal wall.
  properties: [unwalkable, known]

- name: up and horizontal wall
  display:
    attr: entity
    char: '┴'
  description:
    - A up and horizontal wall.
  properties: [unwalkable, known]

- name: left and vertical wall
  display:
    attr: entity
    char: '┤'
  description:
    - A left and vertical wall.
  properties: [unwalkable, known]

- name: right and vertical wall
  display:
    attr: entity
    char: '├'
  description:
    - A right and vertical wall.
  properties: [unwalkable, known]

- name: horizontal wall
  display:
    attr: entity
    char: '─'
  description:
    - A horizontal wall.
  properties: [unwalkable, known]

- name: vertical wall
  display:
    attr: entity
    char: '│'
  description:
    - A vertical wall.
  properties: [unwalkable, known]

############################################################
### Devices ################################################
############################################################

- name: bitcoin
  display:
    char: '₿'
    attr: gold
  description:
    - A beautiful round shaped piece of metal that seems to be of great value
      to the aliens on this planet.
    - Just like the bit it has two sides and when you flip it, it lands perfectly
      randomly on one of the sides.
  properties: [portable]
  capabilities: [random]

- name: treads
  plural: treads
  display:
    attr: device
    char: '%'
  description:
  - Installing treads on a robot allows it to move and turn.
  - The `move` command moves the robot forward one unit.
  - 'Example:'
  - '  move; move; // move two units'
  - The `turn` command takes a direction as an argument, which
    can be either absolute (north, west, east, south) or relative
    (left, right, forward, back, down).
  - 'Example:'
  - '  move; turn left; move; turn right'
  capabilities: [move, turn]
  properties: [portable]

- name: tank treads
  plural: tank treads
  display:
    attr: device
    char: '%'
  description:
  - Tank treads work like treads, but are large enough to move even heavy robots around.
  capabilities: [move, turn, moveheavy]
  properties: [portable]

- name: grabber
  display:
    attr: device
    char: '<'
  description:
  - A grabber arm is an all-purpose, hydraulically controlled device that can
    manipulate other items and robots via the `grab`, `place`, `give`,
    and `install` commands.
  - The `grab` command takes no arguments; it simply grabs whatever is
    available, and also returns the name of the grabbed thing as a string.
    It raises an exception if run in a cell that does not contain an item.
  - The `place` command takes one argument, the name of the item to
    place.  The item is removed from the robot's inventory and placed
    in the robot's current cell (which must be empty).  Raises an
    exception if the operation fails.
  - "The `give` command takes two arguments: the robot to
    give an item to (which can be at most 1 cell away), and the name
    of the item to give. Raises an exception if the operation fails."
  - "The `install` command takes two arguments: the robot
    on which to install a device (which can be at most 1 cell away),
    and the name of the device to install."
  capabilities: [grab, give, place, install]
  properties: [portable]

- name: fast grabber
  display:
    attr: device
    char: '≪'
  description:
  - A fast grabber is an improved version of the basic grabber - not only
    can it 'grab', 'place', 'give', and 'install', it can also 'swap'.
  - The 'swap' command allows the robot to execute grab and place at the
    same time so that the location where the robot is standing does not
    become empty.
  - You can use this to prevent failures where multiple robots
    are trying to grab, place or scan a given location.
  - In addition you retain the capability to use the 'atomic' command,
    with which you can implement other commands that are safe when
    run in parallel.
  capabilities: [grab, swap, give, place, install, atomic]
  properties: [portable]

- name: harvester
  display:
    attr: device
    char: '≤'
  description:
  - A harvester can be used via the `harvest` command, which is
    almost identical to the `grab` command.  The big difference
    is that some entities, when harvested instead of grabbed,
    leave behind a seed which will eventually grow into another copy
    of the original entity.
  - For entities which do not grow, `harvest` behaves exactly the same
    as `grab`.
  capabilities: [grab, harvest, place]
  properties: [portable]

- name: toolkit
  display:
    attr: device
    char: 'Ѣ'
  description:
  - "A toolkit can be used, via the `salvage` command, to take apart old robots."
  - "`salvage` takes no arguments. It looks for an inactive
    robot (one which is not currently running a program) in the
    current cell. If an inactive robot is found, its log (if any) is
    downloaded and it is dismantled, transferring its knowledge, devices, and inventory to the
    robot running `salvage`.  If no inactive robots are found in the
    current cell, `salvage` does nothing."
  capabilities: [salvage]
  properties: [portable]

- name: solar panel
  display:
    attr: device
    char: '#'
  description:
  - An extremely efficient solar panel, capable of generating sufficient power
    from ambient starlight alone. A robot powered by one of these can operate any time,
    including on cloudy days and at night.
  capabilities: [power]
  properties: [portable]

- name: drill
  display:
    attr: device
    char: '!'
  description:
  - A drill allows robots to drill through rocks and mountains, and extract resources from mines.
  capabilities: [drill]
  properties: [portable]

- name: metal drill
  display:
    attr: iron
    char: '!'
  description:
  - A metal drill allows robots to drill through rocks and mountains,
     and extract resources from mines, faster than a regular drill.
  - A metal drill is also able to drill deeper than a regular drill.  Thus, some resources
    are only reachable using a metal drill.
  capabilities: [drill]
  properties: [portable]

- name: typewriter
  display:
    attr: device
    char: 'Д'
  description:
  - A typewriter is used to inscribe symbols on paper, thus reifying pure, platonic
    information into a physical form.
  properties: [portable]

- name: 3D printer
  display:
    attr: device
    char: '3'
  description:
  - A 3D printer gives you the capability of printing more robots! You
    can access the 3D printer via the `build` command.
  - 'Example:'
  - '  build {move; grab; turn back; move; give base "tree"}'
  - |
    builds a robot to get the tree on the cell to the
    north (if there is one) and bring it back to the base. The `build` command
    always returns a reference to the newly constructed robot. For example,
  - '  r <- build {move}; view r'
  - |
    builds a robot and then views it.

  properties: [portable]
  capabilities: [build]

- name: dictionary
  display:
    attr: device
    char: 'D'

  description:
  - |
    A dictionary allows a robot to remember definitions and reuse them
    later.  You can access this ability with either a `def` command,
    which creates a name for an expression or command that is
    available from then on, or with a `let` expression, which names an
    expression or command locally within another expression.
  - '  def m2 : cmd unit = move; move end'
  - '  let x : int = 3 in x^2 + 2*x + 1'
  - The type annotations in `def` and `let` are optional.

  properties: [portable]
  capabilities: [env]

- name: branch predictor
  display:
    attr: device
    char: 'y'
  description:
  - |
    A branch predictor is a device which allows a robot to interpret
    conditional expressions.  The syntax for a conditional expression
    is `if` followed by three arguments: a boolean test and then
    two delayed expressions (i.e. expressions in curly braces) of the same type.
  - 'Example:'
  - 'if (x > 3) {move} {turn right; move}'
  properties: [portable]
  capabilities: [cond]

- name: detonator
  display:
    attr: fire
    char: '*'
  description:
  - An explosive device which can be used to self-destruct, via the
    `selfdestruct` command.  Immediately vaporizes the robot and any
    inventory it is carrying.  Can be useful, say, if you are sending
    out some exploratory robots and don't want them cluttering up the
    world once they are done.
  properties: [portable]
  capabilities: [selfdestruct]

- name: life support system
  display:
    attr: device
    char: 'Ж'
  description:
  - A state-of-the-art life support system which maintains the
    particular temperature and mixture of gases you need to survive.
    It uses a sophisticated recirculating system and can run pretty
    much indefinitely.  Unfortunately, the atmosphere outside is
    severely toxic (why do the inhabitants of this planet need so much
    nitrogen!?), so you'll have to stay inside for now.
  properties: [portable]

- name: scanner
  display:
    attr: device
    char: '$'
  description:
  - "With a scanner device, robots can use the `scan` command to learn
    about their surroundings.  Simply give `scan` a direction in which to scan,
    and information about the scanned item (if any) will be added to the robot's
    inventory."
  - "A scanner also enables the `blocked` command, which returns a
     boolean value indicating whether the robot's path is blocked
     (i.e. whether executing a `move` command would fail)."
  - "Finally, robots can use the `upload` command to copy their accumulated
    knowledge to another nearby robot; for example, `upload base`."
  properties: [portable]
  capabilities: [scan, sensefront, sensehere]

- name: flash memory
  display:
    attr: device
    char: '§'
  description:
  - "A compact, non-volatile memory device, capable of storing
    up to 8 pZ of data."
  - "Flash memory can be used as a component of other devices.  In addition,
     a flash memory device can be used to reprogram other robots using the
     `reprogram` command."
  - "The robot being reprogrammed must be idle, and must possess enough capabilities to run the new command;
     otherwise reprogramming will fail."
  properties: [portable]
  capabilities: [reprogram]

- name: mirror
  display:
    attr: device
    char: 'U'
  description:
  - "With a mirror, robots can reflect on themselves and see their own name."
  - "A mirror enables the `whoami` command, which returns the robot's
     name as a string."
  - "It also enables the special `self` variable, which gives a robot
    a reference to itself."
  properties: [portable]
  capabilities: [whoami]

- name: logger
  display:
    attr: device
    char: 'l'
  description:
  - "Allows a robot to generate and store messages for later viewing,
    using the `log` command, which takes a string.  Log messages are
    also automatically generated by uncaught exceptions."
  properties: [portable]
  capabilities: [log]

- name: hearing aid
  display:
    attr: device
    char: '@'
  description:
  - "Allows a robot to hear what nearby robots are saying."
  - "Simply having this device installed will automatically
     add messages said by nearby robots to this robot's log,
     assuming it has a logger installed."
  - "That way you can view any heard message later either in
     the logger or the message window."
  - "To wait for a message and get the string value, use:"
  - "`l <- listen; log $ \"I have waited for someone to say \" ++ l`"
  properties: [portable]
  capabilities: [listen]

- name: counter
  display:
    attr: device
    char: 'C'
  description:
  - |
    A counter enables the command `count : string -> cmd int`,
    which counts how many occurrences of an entity are currently
    in the inventory.  This is an upgraded version of the `has`
    command, which returns a bool instead of an int and does
    not require any special device.
  properties: [portable]
  capabilities: [count]

- name: calculator
  display:
    attr: device
    char: '+'
  description:
  - "A calculator allows a robot to do basic arithmetic calculations:
    addition, subtraction, multiplication, division, and
    exponentiation."
  properties: [portable]
  capabilities: [arith]

- name: ADT calculator
  display:
    attr: device
    char: '±'
  description:
  - |
    A calculator with Advanced Display Technology (an attached
    typewriter that can print out the results).  For some reason, in
    addition to the usual arithmetic on numbers, an ADT calculator can
    also do arithmetic on types!  After all, the helpful typewritten manual
    explains, a type is just a collection of values, and a finite collection
    of values is just a fancy number.  For example, the type `bool` is
    just a fancy version of the number 2, where the two things happen to be
    labelled `false` and `true`.
  - |
    The product of two types is a type of pairs, since, for example,
    if `t` is a type with three elements, then there are 2 * 3 = 6
    different pairs containing a `bool` and a `t`, that is, 6 elements
    of type `bool * t`.  For working with products of types, the ADT
    calculator enables pair syntax `(a, b)` as well as the projection
    functions `fst : a * b -> a` and `snd : a * b -> b`.
  - |
    The sum of two types is a type with two options; for example, a
    value of type `bool + t` is either a `bool` value or a `t` value,
    and there are 2 + 3 = 5 such values.  For working with sums of
    types, the ADT calculator provides the injection functions `inl :
    a -> a + b` and `inr : b -> a + b`, as well as the case analysis
    function `case : (a + b) -> (a -> c) -> (b -> c) -> c`.  For
    example, `case (inl 3) (\x. 2*x) (\y. 3*y) == 6`, and `case (inr
    3) (\x. 2*x) (\y. 3*y) == 9`.

  properties: [portable]
  capabilities: [arith, sum, prod]

- name: compass
  display:
    attr: device
    char: 'N'
  description:
  - "A compass gives a robot the ability to orient using cardinal directions: north, south, west, and east."
  - "Example:"
  - "turn west; move; turn north"
  properties: [portable]
  capabilities: [orient]

- name: clock
  display:
    attr: device
    char: '0'
  description:
  - A clock is a device for keeping track of time.  It enables the `wait` and `time` commands.
  - |
    `time : cmd int` returns the current time, measured in game ticks since the beginning of the game.
  - |
    `wait : int -> cmd unit` causes a robot to sleep for a specified amount of time (measured in game ticks).
  properties: [portable]
  capabilities: [time]

- name: comparator
  display:
    attr: device
    char: '>'
  description:
  - "A comparator allows comparing two values to see whether the first
    is less, equal, or greater than the second."
  - "Valid comparison operators are <, <=, >, >=, ==, and !=."
  properties: [portable]
  capabilities: [compare]

- name: I/O cable
  display:
    attr: device
    char: 'Ю'
  description:
  - An I/O cable can be used to communicate with an adjacent robot.
  properties: [portable]

- name: rubber band
  display:
    attr: device
    char: 'O'
  description:
  - "A rubber band can tie multiple commands together so that other robots can't execute
    commands in between them.  It can be used via the `atomic` command. For example, suppose
    robot A executes the following code:"
  - |
    b <- ishere "rock"; if b {grab} {}

  - "This seems like a safe way to execute `grab` only when there is a
    rock to grab.  However, it is actually possible for the `grab` to
    fail, if some other robot B snatches the rock right after robot A sensed
    it and before robot A got around to grab it on the next game tick."
  - "This will make robot A very sad and it will crash."
  - "To prevent this situation, robot A can wrap the commands in `atomic`, like so:"
  - |
    atomic (b <- ishere "rock"; if b {grab} {})

  properties: [portable]
  capabilities: [atomic]

- name: net
  display:
    attr: silver
    char: '#'
  description:
  - A net is a device woven out of many strings.  With a net
    installed, you can use the `try` command to catch errors. For example,
  - |
    `try {move} {turn left}`
  - will attempt to move, but if that fails, turn left instead.
  properties: [portable]
  capabilities: [try]