#!/usr/bin/python
# -*- coding: utf-8 -*-
import numpy as np
"""
This program is an extensible Conway's game of life. It allows to define
different type of grid (for example 2D or 3D) and more complex rules.
Each grid inherits an Abstract grid that implement the method (next())
to pass for the next configuration.
Furthermore, each element can be whatever type. In this
example I designed Grid2DBool that represent the simple Conway's game of life,
but could be possible to develop and easily implement more complex grids and
rules.
Note:
The demo save also the animation in a file .mp4 and plot it through pyplot.
The demo could take long time because of storing all the configurations before
showing the animation. Therefore, the visualization can be improved using other
libraries (as wxpython) that paint the configuration of the grid once it's
created.
With a more complex view it's convenient to apply MVC pattern declaring the
model AbstractGrid as the Observable class.
@author Filippo Squillace
@date 02/12/2011
@version 0.0.5
"""
class AbstractGrid():
"""
This class represents the abstract grid that implement
the template method to generate the next configuration. The rules are
definied in the abstract method next_state() and it's not
implemented in this class because depends on the structure of the matrix
and the type of elements in the grid.
"""
def __init__(self):
self.matrix = np.array([], dtype=bool)
def __str__(self):
return self.matrix.__str__()
####### Abstract methods ########
def next_state(self, coords, el):
raise NotImplementedError()
def is_done(self):
raise NotImplementedError()
################################
def add_element(self, coords, el):
self.matrix[coords] = el
def next(self):
# copy the matrix
old_matrix = self.matrix.copy()
itr = self.matrix.flat
coords = itr.coords
for el in itr:
old_matrix[coords] = self.next_state(coords, el)
coords = itr.coords
# copy all the modifications
self.matrix = old_matrix
class Grid2D(AbstractGrid):
def __init__(self, n, m, typ=bool):
AbstractGrid.__init__(self)
self.n = n
self.m = m
self.matrix = np.array([None for x in range(n*m)], dtype=typ).reshape(n,m)
class Grid2DBool(Grid2D):
"""
Represents the classical Conway's game of life with 2D grid
and each element can be either True (alive) or Fase (death)
Params:
n - number of rows
m - number of columns
"""
def __init__(self, n, m):
Grid2D.__init__(self, n, m, bool)
def add_element(self, x, y):
t = (x, y)
Grid2D.add_element(self, t, True)
def next_state(self, coords, el):
# Gets all information from the neighbors
(x, y) = coords
neighbors = 0
if x==0:
x1=0
else:
x1=x-1
if x==self.n-1:
x2=self.n-1
else:
x2=x+1
if y==0:
y1=0
else:
y1=y-1
if y==self.m-1:
y2=self.m-1
else:
y2=y+1
for n in self.matrix[x1:x2+1, y1:y2+1].flat:
if n:
neighbors = neighbors + 1
# Excludes the main element
if el:
neighbors = neighbors - 1
if el: # el alives
if neighbors==2 or neighbors==3:
return True
if neighbors<2 or neighbors>3:
return False
else: # el death
if neighbors==3:
return True
def is_done(self):
return not self.matrix.max() # there is no True
def light_spaceship(g, x, y, invert=False):
"""
Puts the lightweight spaceship right in the grid starting from icoords
"""
if not invert:
g.add_element(x,y)
g.add_element(x+2,y)
g.add_element(x+3,y+1)
g.add_element(x+3,y+2)
g.add_element(x+3,y+3)
g.add_element(x+3,y+4)
g.add_element(x+2,y+4)
g.add_element(x+1,y+4)
g.add_element(x,y+3)
else:
g.add_element(x,y)
g.add_element(x+2,y)
g.add_element(x+3,y-1)
g.add_element(x+3,y-2)
g.add_element(x+3,y-3)
g.add_element(x+3,y-4)
g.add_element(x+2,y-4)
g.add_element(x+1,y-4)
g.add_element(x,y-3)
if __name__ == '__main__':
import matplotlib.pyplot as plt
import matplotlib.animation as animation
n = 50
g = Grid2DBool(n, n)
light_spaceship(g, 5,2)
light_spaceship(g, 25,2)
light_spaceship(g, 45,2)
light_spaceship(g, 5,40, True)
light_spaceship(g, 25,40, True)
light_spaceship(g, 45,40, True)
x = np.arange(0, n+1)
y = np.arange(0, n+1)
X,Y = np.meshgrid(x,y)
ims = []
ims.append((plt.pcolor(X, Y, g.matrix),))
counter = 0
while(not g.is_done() and counter < 100):
g.next()
ims.append((plt.pcolor(X, Y, g.matrix),))
counter = counter + 1
fig = plt.figure(1)
im_ani = animation.ArtistAnimation(fig, ims, interval=2,\
repeat_delay=3000,\
blit=True)
im_ani.save('im.mp4')
plt.axis([0, n, n, 0])
plt.axis('off')
plt.show()
