CSCI 150: Lab 7

Describe the Problem:

Understand the Problem:

Design an Algorithm:

We will be creating the game of life using two different classes: one for the game board, and one for each cell.

Cell Class

The Cell class represents square cells in the Game of Life. Each turn of the game, each cell will be updated based on the rules of the game. Because each cell has a different location and a different status (i.e., alive or empty), the Cell class should have four instance variables:

• integers x and y, which represent its location the board
• Boolean alive which is True if the cell is alive, and False if it's not, and
• Boolean last, which stores whether or not it was alive on the last turn (this is helpful for when we are updating the board)

The Cell class should also have the following methods:

• __init__(self, x, y), which is a constructor that sets the initial values for the self.x and self.y instance variables to be the values of the parameters x and y. It should also set both self.alive and self.last to False


• countNeighbors(self, cells), which is a method for counting how many neighbors to this cell are currently alive. Here, the cells parameter is a list of lists of Cell objects that make up the rest of the board. As a hint,
  
  

  neighbor = cells[neighbor_x][neighbor_y]
  

  will save a particular Cell into a new variable called neighbor whose coordinates are (neighbor_x, neighbor_y) in the board. We can then use neighbor.last to get the value of the last instance variable to see whether neighbor is current alive or empty (we cannot use neighbor.alive since that may or may not have already been updated while we are updating the current self instance). Recall that each Cell has 8 neighbors; below we discuss how to handle the special cases of a Cell on the edge of the board.


• update(self, cells), which is responsible for updating the self.alive instance variable of this Cell instance. It should use self.countNeighbors(cells) to count how many of its neighbors are currently alive, then combine that with self.alive to follow the rules of the Game of Life to decide if the cell should now be alive (self.alive = True) or empty (self.alive = False).

    north_y = (self.y - 1) % h
    east_x = (self.x + 1) % w
    south_y = (self.y + 1) % h
    west_x = (self.x - 1) % w

    north_neighbor = cells[self.x][north_y]
    northeast_neighbor = cells[east_x][north_y]
    east_neighbor = cells[east_x][self.y]
    # etc. for the other 5 neighbors

Board Class

The Board class will represent the collection of all of the Cells that make up the entire game. Thus, it should have one instance variable:

• cells, which is a two dimensional list (i.e., a list of lists) that stores all of the Cell instances in the board. As described above, cells[x][y] should store the Cell located at (x, y).

The Board class should have the following methods:

• __init__(self, width, height), which is a constructor that creates the self.cells instance variable to be a list that has width number of inner lists (each inner list corresponds to a column of the board), and each inner list has height number of Cell objects (one for each row of the column of the board). Two nested for loops might be really helpful here. Please note that this method will create the Cell instances that will be stored in that list of lists by calling the Cell constructor and passing in the correct x and y values for each Cell instance.


• initialize(self, setup) should assign a True value to the alive instance variables of specific cells, based on the setup number passed in as the setup parameter. We provide details about what you should do for setup = 1 below; you should come up with two more interesting options for setups 2 and 3. Check out the Life Wiki for some ideas.
  
  

  The first starting configuration should include just the 5-cell pattern below, somewhere in the middle of the board. For the other two, find a couple configurations that generate interesting effects.

  
  
  
  
  The first starting configuration.



• update(self) should first copy the value in the alive instance variable of each Cell in self.cells to the same Cell's last instance variable using two nested for loops. Then after those loops have completed, it should call the update method for each Cell, again using two nested for loops.


• draw(self, canvas, force) which will update the drawing of the board on a Picture object (from the picture module used in Lab 3) called canvas. In particular, it should draw a rectangle with a width and height of 10 pixels for each Cell that is colored red if the Cell is alive and white if the Cell is empty. The top left corner of each rectangle depends on its Cell's x and y instance variables and the fact that each rectangle is 10 pixels wide and tall.
  
  Because drawing many Cells will take some time and only some will change color each time the update method is called, we are going to optimize this draw method. The force parameter should take a default value of False, and it will determine whether you draw every rectangle (when force == True) or only the rectangles for those Cells that changed status during the current turn (when force == False). To determine whether the status of a Cell changed during the current turn, we can compare their alive and last instance variables and see if those Boolean values are different.

Implement a Design

Testing your Cell Class First

To help you debug your Cell class before working on the Board class and later complete the Game of Life, we have provided a test program test_cell.py that will use the Cell class that you implemented in the life.py file. If your Cell class is implemented correctly, you should see the following output when you run the test_cell.py program:

Cell 5,6 has 2 alive neighbors
..........
..........
..........
..........
..........
.....xxx..
..........
..........
..........
..........

..........
..........
..........
..........
......x...
......x...
......x...
..........
..........
..........

..........
..........
..........
..........
..........
.....xxx..
..........
..........
..........
..........
			

Final Program Narrative

After you implement the Cell and Board classes above (and know that your Cell class is working), you should create a main function that does the following:

1. Ask the user for a setup number


2. Create an instance of the Board class with width of 50 and a height of 80


3. Call the initialize method of your new Board instance with the setup number provided by the user


4. Create a Picture object that is 500 pixels wide and 800 pixels tall for drawing the game


5. Call the draw method of your Board instance using the Picture you just created and a force = True so that every rectangle is drawn.


6. Using a loop that runs for 100 generations, repeatedly call the update method of your Board instance, then call its draw method with the aforementioned Picture object (and no argument for force so that takes on the default value of False) to display the changes in the Cells.

Aging Cells (Optional)

Keep track of how many rounds each live cell has been alive, and color the cell based on that age. For example, you might have newborn cells begin red but slowly turn blue as long as they stay alive.

Maintain: