Termites¶

I wrote a class called Termite that extends Bug and adds the ability to interact with flowers. To run it, download these files and import them into your development environment:

Termite.java, Termite.gif, TermiteRunner.java, and EternalFlower.java.

Because Termite extends Bug, all Bug methods also work on Termites. But Termites have additional methods that Bugs don’t have.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/**
 * Returns true if the termite has a flower.
 */
public boolean hasFlower();

/**
 * Returns true if the termite is facing a flower.
 */
public boolean seeFlower();

/**
 * Creates a flower unless the termite already has one.
 */
public void createFlower();

/**
 * Drops the flower in the termites current location.
 *
 * Note: only one Actor can occupy a grid cell, so the effect
 * of dropping a flower is delayed until the termite moves.
 */
public void dropFlower();

/**
 * Throws the flower into the location the termite is facing.
 */
public void throwFlower();

/**
 * Picks up the flower the termite is facing, if there is
 * one, and if the termite doesn't already have a flower.
 */
public void pickUpFlower();

For some methods Bug provides one definition and Termite provides another. In that case, the Termite method overrides the Bug method.

For example, Bug.canMove returns true if there is a flower in the next location, so Bugs can trample Flowers. Termite.canMove returns false if there is any object in the next location, so Termite behavior is different.

As another example, Termites have a version of turn that takes an integer number of degrees as a parameter. Finally, Termites have randomTurn, which turns left or right 45 degrees at random.

Here is the code from TermiteRunner.java:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class TermiteRunner
{
    public static void main(String[] args)
    {
        ActorWorld world = new ActorWorld();
        makeFlowers(world, 20);

        Termite alice = new Termite();
        world.add(alice);

        Termite bob = new Termite();
        bob.setColor(Color.blue);
        world.add(bob);

        world.show();
    }

    public static void makeFlowers(ActorWorld world, int n) {
        for (int i = 0; i<n; i++) {
            world.add(new EternalFlower());
        }
    }
}

Everything here should be familiar. TermiteRunner creates an ActorWorld with 20 EternalFlowers and two Termites.

An EternalFlower is a Flower that overrides act so the flowers don’t get darker.

public class EternalFlower extends Flower {
    public void act() {}
}

If you run TermiteRunner.java you should see two termites moving at random among the flowers.

MyTermite.java demonstrates the methods that interact with flowers. Here is the class definition:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class MyTermite extends Termite {

    public void act() {
        if (getGrid() == null)
            return;

        if (seeFlower()) {
            pickUpFlower();
        }
        if (hasFlower()) {
            dropFlower();
        }

        if (canMove()) {
            move();
        }
        randomTurn();
    }
}

MyTermite extends Termite and overrides act. If MyTermite sees a flower, it picks it up. If it has a flower, it drops it.

Langton’s Termite¶

Langton’s Ant is a simple model of ant behavior that displays surprisingly complex behavior. The Ant lives on a grid like GridWorld where each cell is either white or black. The Ant moves according to these rules:

• If the Ant is on a white cell, it turns to the right, makes the cell black, and moves forward.
• If the Ant is on a black cell, it turns to the left, makes the cell white, and moves forward.

Because the rules are simple, you might expect the Ant to do something simple like make a square or repeat a simple pattern. But starting on a grid with all white cells, the Ant makes more than 10,000 steps in a seemingly random pattern before it settles into a repeating loop of 104 steps.

You can read more about Langton’s Ant at Wikipedia.

It is not easy to implement Langton’s Ant in GridWorld because we can’t set the color of the cells. As an alternative, we can use Flowers to mark cells, but we can’t have an Ant and a Flower in the same cell, so we can’t implement the Ant rules exactly.

Instead we’ll create what I’ll call a LangtonTermite, which uses seeFlower to check whether there is a flower in the next cell, pickUpFlower to pick it up, and throwFlower to put a flower in the next cell. You might want to read the code for these methods to be sure you know what they do.

Exercises¶