Antomata - The Language of Ant Wars

Contents

• Introduction
• The State Machine
• Syntax
  • Constants
  • States
  • Conditionals
  • Tests
  • Commands
  • Grouping
  • Comments

Introduction

The Ant Wars compiler, which is part of the standard distribution, takes a program written with a Scheme syntax and converts it to a bytecode form used by the simulator. Ant Wars 'brains', as the programs are called, consist only of constants, states, commands and conditionals. There is no memory such as a stack or heap.

Each Ant Wars brain must consist of at least one state. Each state may consist of zero or more conditionals and commands, and flow must never reach the end of a state. The following is an example of a very minimal (and pretty much useless) ant brain:

(define-state start
   (turn left)
   (-> start))
    

This ant merely spins left, in place. Note the (-> start) at the end of the state. It is important that if control reaches the end of the state that control is redirected, either back to the same state, or to another state. This statement says to transfer control to the state labeled start.

The State Machine

Most ant brains will have more than a single state. There are two scopes for states in Antomata: global and local. The example above is a global state, which means that control may be transferred to that state from any other state in the program. Local states are defined within a global state, and may only be jumped to from within that global state or another local state therein. The following example shows how to implement the minimal ant brain above using local states:

(define-state start
   (states ((spin-left
              (turn left)
              (-> spin-left)))
      (-> spin-left)))
    

In this example, the global state start defines a local state spin-left. This local state can only be accessed from within the start global state or any local states defined within it. A slightly more complicated example illustrates this:

(define-state start
    (states
        ((spin-left
             (turn left)
             (turn left)
             (turn left)
             (-> spin-right))
         (spin-right
             (turn right)
             (turn right)
             (turn right)
             (-> spin-left)))
      (-> spin-left)))
    

In this example, control is transferred to spin-left which causes the ant to turn left three times. Then control is transferred to the local spin-right state, wherein the ant turns right three times. Control then goes back to spin-left and the process repeats.

When any state defines local states, it must specify which local state should receive control when the global state receives control. This is specified by the last expression in the states block, which in this case reads -> spin-left. More complicated expressions are allowed, as can be seen below.

(define-state start
    (states 
        ((spin-left
             (turn left)
             (turn left)
             (turn left)
             (-> spin-right))
         (spin-right
             (turn right)
             (turn right)
             (turn right)
             (-> spin-left)))
     (if (flip 2)
         (-> spin-left)
         (-> spin-right))))
    

For this definition of start, control will be transferred to either spin-left or spin-right with equal chance (the flip statement will be described in more detail later.)

More detailed examples are part of the standard distribution and, when used with this document, should provide a solid foundation for building new ants.

Statements and Syntax

The following section specifies all of the valid commands and syntax for the standard Ant Wars language, Antomata.

Constants

In Antomata, integer values may be assigned names for use anywhere an integer value is allowed.

States

States may be declared both globally and locally. At least one global state must exist within any program.

Conditionals

Conditional statements are used to make decisions.

Tests

Tests are used inside conditionals to make decisions. Some Tests also cause the ant to perform an action, much like a Command.

Commands

These are statements which cause the ant to take action unconditionally.

Grouping

Comments

There are two types of comments: line and region. Line comments begin with a semicolon (;) and run until the end of the line. Region comments begin with #| and end with |# and may span multiple lines.