swarm-0.1.0.0: data/entities.yaml
- 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]