Objectives:

• Practice with arrays of objects
• Using two-dimensional array concepts.
• Using this to have an object pass a reference to itself to another object.
• Use polymorphism.

Check-off procedure:

You must attend the recitation and sign in. Because of student evaluations taking place during the week of November 29, the following check-off rules apply. In order to receive 7 points on the lab, you must attend a lab session during the week of November 29. To earn the remaining credit, you can either:

• Finish the problem on your own and hand in your hi-lighted source,
• Attend a second lab session on this problem during the week of December 6.

Laboratory details:

The Game of Life is a famous board game invented by Mathematician John Conway. The board consists of n x m cells. Each cell is either alive or dead. The board starts with an initial set of dead and alive cells. At the next time step, a cell determines whether it is alive or dead by the following rules:

• Live cells:
  • will survive at the next time step if 2 or three of their neighbors are alive.
  • will die at the next time step (of loneliness) if they have less than 2 neighbors
  • will die at the next time step (of suffocation) if they have more than 3 neighbors.
• Dead cells:
  • will be born at the next time step if they have exactly 3 neighbors.
  • will stay dead at the next time step if they don't have exactly 3 neighbors.

In this assignment, the cells are implemented as Cell objects. The Cell class is given. You are to implement the game of life using a two-dimensional array of Cell objects to represent the board.

The game of life has received a great deal of attention as a simple model of how populations of a species behave. Much work has been done to determine which initial patterns on the board produce interesting behavior. In this laboratory, you will determine whether a particular cell is alive or dead at random. Here are some web sites devoted to the game of life, if you would like to observe it in action or learn more about it:

• http://www.bitstorm.org/gameoflife/
• http://www.tech.org/~stuart/life/
• http://www.mindspring.com/~alanh/life/
• http://www.pentadecathlon.com/lifeInfo/OtherLinks.html
• http://www.math.kth.se/~gunnarj/LIFE/WLIF/wlcframes.html (Games of life in color)

Part I: The Setup

• Create a new standalone project entitled LifeMain.
• Copy the Cell.java file (shown at the bottom of the handout) into your project directory and add it to the LifeMain project.
• Create a new file called Life.java and add the following skeleton to it:

  public class Life {
  
  
     //constructor
     public Life (int rows, int columns) {
  
     }
  
     //accessors
     public void printBoard() {
  
     }
  
  }
  

• Build and run the program.

• Implement accessor methods to get the number of rows and columns on the board. Build, run and test.

Part II: Initializing the Board

• Add a private field called myBoard to Life. myBoard is a two-dimensional array of Cell.

• Add code to the constructor to initialize myBoard to have the number of rows and columns that have been passed as parameters.

• Add code to the constructor to initialize each Cell in myBoard. Each Cell object should be initially alive. (The third parameter of the constructor for Cell will be true.)

• Build and run.

• Implement the printBoard method.

• Build and run.

• Add code to the LifeMain to instantiate a Life object that is 5 rows by 4 columns. Call the printBoard method to output the state of the board.

• Modify the constructor of Life so that instead of initializing all of the cells to being alive initially, the cells will be randomly selected to be alive. (You can use your Dice class, or directly call Math.random().)

Part III: The Game of Life

• Implement the isAlive method for the Life class. The method returns whether the cell at the indicated position is alive or not. The method assumes that the board wraps around both on top and bottom. For example, if row is -1, the row is taken to be myRows - 1.

      public boolean isAlive(int row, int column) {
          // assume that the board wraps around
          int i = getWrapIndex(row, myRows);
          int j = getWrapIndex(column, myColumns);
          return myBoard[i][j].isAlive();
      }
  

• Add the private helper function that handles index wrap:

       private int getWrapIndex(int index, int limit) {
           if (index >= 0)
              return index%limit;
          else {
              int temp = Math.abs(index/limit);
              return (index + (temp+1)*limit)%limit;
          }
       }   
  

• Test the isAlive method by calling it from LifeMain with various values of row and column and make sure that it is working correctly.

• Implement a method called age:
  • The age method makes one pass through the entire board, calling the findFuture method for each cell. This pass tells each cell to figure out what its next state is going to be.

  • The age method then makes another pass through the board, calling the age method for each cell. This pass tells each cell to take one time step forward.

• Build and run and test the program.

Part IV: Reflecting Boundaries

• Add a second constructor for Life of the form:

     public Life (int rows, int columns, boolean reflecting) {
  
     }
  

• Add a field called myReflecting that is by default false. In this form of the constructor, myReflecting is set to reflecting. Modify the isAlive method for Life so that if myReflecting is true, the board is treated as having reflecting boundaries rather than wrapping boundaries. For example, cell (-1, -1) is cell (1, 1) while cell (-1, 2) is cell (1, 2).

• Add test code to LifeMain to test the life came with and without reflecting boundaries.

Cell.java

public class Cell {
    private int myRow;
    private int myColumn;
    private Life myWorld;
    private boolean myExistence;
    private boolean myFutureExistence;
   
    // constructor
     public Cell(Life world, int row, int column, boolean alive) {
        myWorld = world;
        myRow = row;
        myColumn = column;
        myExistence = alive;
        myFutureExistence = false;
    }
   
    // accessors
    public int getRow() {
        return myRow;
    }

    public int getColumn() {
        return myColumn;
    }

    public boolean isAlive() {
        return myExistence;
    }


    // Find out whether cell will be alive at the next time step
    public boolean isAliveInFuture() {
        int neighbors = getNumberNeighbors(); 
        if (!myExistence && neighbors == 3) 
           myFutureExistence = true; 
        else if (myExistence && (neighbors == 2 || neighbors == 3)) 
           myFutureExistence = true; 
        else 
           myFutureExistence = false; 
        return myFutureExistence;
    }   
    
    // modifier - moves the cell ahead one time step
    public void age() {
        myExistence = myFutureExistence;
    }   
    
    //  helper - returns number of live neighbors
    public int getNumberNeighbors() {
        int count = 0;
        for (int i = myRow - 1; i <= myRow + 1; i++) {
            for (int j = myColumn - 1; j <= myColumn + 1; j++) {
                if (myWorld.isAlive(i,j))
                    count++;
            }
        }      
        // If I'm currently alive I counted myself in the above loop
        if (isAlive())
           count--;
        return count;
    }
}