GameofLife

import random
import pygame, sys
from pygame.locals import *
from optparse import OptionParser

#options
parser = OptionParser()
parser.add_option('-w', '--width',
					dest='width', default=500,
					help='The width of the panel.')
parser.add_option('-f', '--fps',
					dest='fps', default=10,
					help='The frames per second.')
parser.add_option('-l', '--length',
					dest='height', default=500,
					help='The length (height) of the panel.')
parser.add_option('-s', '--cell_size',
					dest='cell_size', default=10,
					help='The size of each individual cell.')
(options, args) = parser.parse_args()

#setting variables from options
fps = int(options.fps)
width = int(options.width)
height = int(options.height)
cell_size = int(options.cell_size)

#other fixed variables
cwidth = width/cell_size
cheight = height/cell_size
black = (0, 0, 0)
white = (255,255,255)
gray = (40, 40, 40)
panel = pygame.display.set_mode((width, height))

#draws the grid on the panel
def drawGrid():
	for x in range(0, width, cell_size):
		pygame.draw.line(panel, gray, (x, 0), (x, height))
	for y in range(0, height, cell_size):
		pygame.draw.line(panel, gray, (0, y), (width, y))

#creates a grid of all dead (0) cells		
def blankGrid():
	grid = {}
	for y in range (cheight):
		for x in range (cwidth):
			grid[x,y] = 0
	return grid

#randomly sets each cell to alive (1) or dead (0)
def randomStates(cell_states):
	for i in cell_states:
		cell_states[i] = random.randint(0,1)
	return cell_states

#colors the living cells black and the dead cells white	
def colorLiving(i, cell_states):
	x = i[0]
	y = i[1]
	y = y * cell_size
	x = x * cell_size
	if cell_states[i] == 0:
		pygame.draw.rect(panel, white, (x, y, cell_size, cell_size))
	if cell_states[i] == 1:
		pygame.draw.rect(panel, black, (x, y, cell_size, cell_size))
	return None

#counts how many living neighbors a cell has
def neighborCount (i, cell_states):
	neighbors = 0
	for x in range (-1,2):
		for y in range (-1,2):
			checkCell = (i[0] + x, i[1] + y)
			if checkCell[0] < cwidth and checkCell[0] >= 0:
				if checkCell[1] < cheight and checkCell[1] >= 0:
					if cell_states[checkCell] == 1:
						if x == 0 and y == 0:
							neighbors += 0
						else:
							neighbors += 1
	return neighbors
	
#creates the next generation of cells
def gen (cell_states):
	newGen = {}
	for i in cell_states:
		neighbors = neighborCount(i, cell_states)
		if cell_states[i] == 1:
			if neighbors < 2:
				newGen[i] = 0
			elif neighbors > 3:
				newGen[i] = 0
			else:
				newGen[i] = 1
		elif cell_states[i] == 0:
			if neighbors == 3:
				newGen[i] = 1
			else:
				newGen[i] = 0
	return newGen
	
def main():
	
	#initializes pygame
	pygame.init()
	
	#creates a clock for how often to update the display
	fpsclock = pygame.time.Clock()
	
	#sets the pygame caption
	pygame.display.set_caption('CA')

	panel.fill(white)
	
	cell_states = blankGrid()
	cell_states = randomStates(cell_states)
	
	for i in cell_states:
		colorLiving(i, cell_states)
	
	drawGrid()
	pygame.display.update()
	
	
	while True:
		for event in pygame.event.get():
			if event.type == QUIT:
				pygame.quit()
				sys.exit()
		cell_states = gen(cell_states)
		
		for i in cell_states:
			colorLiving(i, cell_states)
		
		drawGrid()
		pygame.display.update()
		fpsclock.tick(fps)
	
if __name__ == '__main__':
	main()