CS 12 -- Lab 2

The Game of Life

The Game of Life is not really a game (you don't play it), but is rather an instance of a cellular automaton. That is, there are a group of cells whose behavior is determined by a set of simple rules. While the behavior of the cell isn't particularly interesting, the behavior of the group and how they interact can be.

Specifically, the Game of Life involves cells on a two-dimensional grid that are either alive or dead. There are rules for when cells are born, when the continue to live, and when they die. This section will describe the details of the Game. Below you will find your specific assignment for implementing this game.

Details of the game:

• The Game is played on a two-dimensional grid of fixed size.
• Each cell can be alive or dead.
• All cells in the grid are evolved to the next generation simultaneously.
• A cell's neighborhood is defined by those cells that are immediately north, south, east, west, northeast, southeast, northwest, and southwest of it on the grid.
• When evolution is computed, this same rule is applied to each cell:
  • The live cell will remain alive if it has 2 or 3 live neighbors.
  • The dead cell will become alive if it has 3 live neighbors.
  • The cell will be dead under all other circumstances.

Your assignment

In short, you must write a program that plays the Game of Life. There are some specifications to how you should write this program. Be sure to following them carefully!

• Use methods to divide your code into logical components. Your solution should not consist of only two or three long methods -- it should consist of a larger number of smaller methods each of which encapsulates a particular task.

• The program should be written in a single, static class. Do not define multiple classes or create objects from your own non-static classes.

• You will need to use (and should use) classes defined by Java itself, particularly for reading and writing files. The Java API documentation will be useful for using these classes.

• The program should take two command-line arguments:

  1. The filename of an initial state file (described below).
  2. The maximum number of generations to evolve.
• The initial state file should be read to obtain the size of the grid and the positions of the initially live cells.
• The grid should be evolved until the maximum number of generations has been research or all cells have become dead.
• The initial grid (which we will refer to as the 0^th generation) and each subsequent generation should be output to the screen. (The formatting for the output is given below.)

Initial state files: This kind of file has a specific format. An initial state file contains integer pairs, one per line of text, separated by a space character. The first line of the file indicates the dimensions of the grid. All subsequent lines of the file contain the coordinates, given in (row, column) pairs of initially live cells.

For example, this initial state file...

4 4
0 1
1 2
2 0
    

...describes a 4-by-4 grid where cells at (0,1), (1,2), and (2,0) are alive in the 0^th generation.

Output format: The output of this program must follow exactly the format given here. The program should produce the following output for each generation computed, including the 0^th:

Generation = 0, Population = 3
-+--
--+-
+---
----

Generation = 1, Population = 0
----
----
----
----
    

The example corresponds to the 0^th generation described by the example initial state file above. The data for each generation should begin with the output of the generation and population numbers, exactly as shown, followed by a textual representation of the grid, where a minus sign (-) denotes a dead cell and a plus sign (+) denotes a live cell.

Sample initial state files: I've provided initial files for you to use during the development of your program. Along with each initial state file is a results file, which contains the output that your program should generate on these samples. To obtain these files, you can copy them from my public CS 12 directory on romulus, like so:

cp ~sfkaplan/public/cs12/simple.init .
cp ~sfkaplan/public/cs12/simple.results .
cp ~sfkaplan/public/cs12/X-pattern.init .
cp ~sfkaplan/public/cs12/X-pattern.results .

The simple case is a small grid where the pattern will repeat every two generations. The X-pattern case is a medium-sized grid that resolves to a static state after a number of (somewhat interesting) steps.

Submitting your work

Use the cs12-submit program to submit only your source code, which should have been written as a single file. Submit your work as project-1, like so:

cs12-submit lab-2 Life.java