new file mode 100644

@@ -0,0 +1,31 @@

+Copyright (c) 2012 Edward Langley

+All rights reserved.

+

+Redistribution and use in source and binary forms, with or without

+modification, are permitted provided that the following conditions

+are met:

+

+Redistributions of source code must retain the above copyright notice,

+this list of conditions and the following disclaimer.

+

+Redistributions in binary form must reproduce the above copyright

+notice, this list of conditions and the following disclaimer in the

+documentation and/or other materials provided with the distribution.

+

+Neither the name of the project's author nor the names of its

+contributors may be used to endorse or promote products derived from

+this software without specific prior written permission.

+

+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+

+

new file mode 100644

@@ -0,0 +1,147 @@

+from __future__ import print_function

+#  

+#  Copyright (c) 2012 Edward Langley

+#  All rights reserved.

+#  

+#  Redistribution and use in source and binary forms, with or without

+#  modification, are permitted provided that the following conditions

+#  are met:

+#  

+#  Redistributions of source code must retain the above copyright notice,

+#  this list of conditions and the following disclaimer.

+#  

+#  Redistributions in binary form must reproduce the above copyright

+#  notice, this list of conditions and the following disclaimer in the

+#  documentation and/or other materials provided with the distribution.

+#  

+#  Neither the name of the project's author nor the names of its

+#  contributors may be used to endorse or promote products derived from

+#  this software without specific prior written permission.

+#  

+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

+#  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

+#  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

+#  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

+#  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

+#  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+#  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+#  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+#  

+#  

+

+import time

+import random

+import pygame

+import sys

+import collections

+import game

+

+import collections

+

+############### Cell ################

+class Cell(game.Cell):

+	pass

+

+Cell.add_rule(3)(0)

+Cell.add_rule(2)(3)

+

+@Cell.add_rule(1)

+def hook_1(cell):

+	neighbors = [c and c.value for c in cell.neighbors]

+	neighbor_value = cell.neighbor_value()

+	rnd = random.random()

+	if 2 in neighbors or 3 in neighbors:

+		if rnd < .62 * neighbor_value/2: return 2

+

+	else:

+		if rnd < .01 * neighbor_value:

+			return 0

+

+@Cell.add_rule(0)

+def hook_0(cell):

+	neighbor_value = cell.neighbor_value()

+	if neighbor_value != 0:

+		nearby_fire = set([2,3]) & set(c and c.value for c in cell.neighbors)

+		if nearby_fire == set() and random.random() < .02 * neighbor_value:

+			return 1

+	return cell.value

+

+########## End Cell #################

+

+class Presence(game.Presence):

+	def act(self):

+		value = int(round( (self.locale.neighbor_value() + self.locale.value) ))

+		self.locale.set_value(0)

+		for x in self.locale.neighbors:

+			if not x: continue

+			if x.value == 1:

+				x.set_value(2)

+

+import time

+

+if __name__ == '__main__':

+	pygame.init()

+	pygame.event.set_allowed([pygame.QUIT, pygame.KEYDOWN])

+	pygame.display.set_caption('Simulator')

+

+	board = game.Board(120, 120)

+	window = pygame.display.set_mode(board.rect.size, pygame.DOUBLEBUF)

+	window.set_alpha(None)

+	for sprite in board.board_group:

+		sprite.image.convert()

+

+	a = game.Controller(board)

+

+	p = a.add_observer(Presence, a.board.init.south)

+	np = a.board.init.southeast

+	for x in range(20):

+		np = np.east

+	np = a.add_observer(Presence, np)

+

+	window.fill( (64,64,64) )

+

+	running = True

+

+	board.board_group.draw(window)

+	pygame.display.flip()

+

+	clck = pygame.time.Clock()

+

+	paused = True

+	while running:

+		clck.tick(80)

+

+		for event in pygame.event.get():

+			if event.type == pygame.QUIT:

+				running=False

+				break

+			elif event.type == pygame.KEYDOWN and event.unicode == 'e':

+				paused = not paused

+			elif event.type == pygame.KEYDOWN and event.unicode == 'w':

+				new = p.locale.north

+				if new:

+					p.locale = new

+			elif event.type == pygame.KEYDOWN and event.unicode == 'a':

+				new = p.locale.west

+				if new:

+					p.locale = new

+			elif event.type == pygame.KEYDOWN and event.unicode == 's':

+				new = p.locale.south

+				if new:

+					p.locale = new

+			elif event.type == pygame.KEYDOWN and event.unicode == 'd':

+				new = p.locale.east

+				if new:

+					p.locale = new

+

+		if not paused:

+			a.step()

+			updates = a.board.board_group.draw(window)

+			pygame.display.update(updates)

+

+		print( clck.get_fps(), '\r', end='' )

+		sys.stdout.flush()

+

new file mode 100644

@@ -0,0 +1,279 @@

+from __future__ import print_function

+#  

+#  Copyright (c) 2012 Edward Langley

+#  All rights reserved.

+#  

+#  Redistribution and use in source and binary forms, with or without

+#  modification, are permitted provided that the following conditions

+#  are met:

+#  

+#  Redistributions of source code must retain the above copyright notice,

+#  this list of conditions and the following disclaimer.

+#  

+#  Redistributions in binary form must reproduce the above copyright

+#  notice, this list of conditions and the following disclaimer in the

+#  documentation and/or other materials provided with the distribution.

+#  

+#  Neither the name of the project's author nor the names of its

+#  contributors may be used to endorse or promote products derived from

+#  this software without specific prior written permission.

+#  

+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

+#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

+#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

+#  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

+#  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

+#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

+#  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

+#  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

+#  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+#  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+#  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+#  

+#  

+

+import sys

+import collections

+import pygame

+

+class Cell(object):

+	north = None

+	south = None

+	east = None

+	west = None

+	rules = {}

+

+

+	def rule(self, *a):

+		'''The rule used to determine the new value for the current cell, add_rule reassigns this based on the current value'''

+		return self.value

+

+	@classmethod

+	def add_rule(self, value):

+		'''Add a rule to correspond to the current value of the cell'''

+		def _inner(rule):

+			self.rules[value] = rule

+			return rule

+		return _inner

+

+	def __init__(self):

+		self.value = None

+		self.update_neighbors()

+

+	def set_value(self, v):

+		'''Change the cells value and select the appropriate rule'''

+		if v != self.value:

+			self.value = v

+			if v is not None:

+				self.rule = self.rules[v]

+

+	def neighbor_value(self):

+		'''Get the total of the values of neighbouring cells'''

+		result = 0

+		for c in self.neighbors:

+			if c is None: continue

+			elif c.value is None: continue

+			result += c.value

+		return result

+

+	def update_neighbors(self):

+		'''Change the neighbors attribute to reflect the current situation'''

+		self.neighbors = (self.north, self.south, self.east, self.west, self.northwest, self.northeast, self.southwest, self.southeast)

+

+	def autoconnect(self):

+		'''Set up the reverse links appropriate to the current situation'''

+		updated = []

+

+		if self.south and self.south.north is not self:

+			self.south.north = self

+			updated.append(self.south)

+		if self.north and self.north.south is not self:

+			self.north.south = self

+			updated.append(self.north)

+		if self.east and self.east.west is not self:

+			self.east.west = self

+			updated.append(self.east)

+		if self.west and self.west.east is not self:

+			self.west.east = self

+			updated.append(self.west)

+

+		for up in updated:

+			up.autoconnect()

+

+		self.update_neighbors()

+

+	@property

+	def northeast(self):

+		r = self.north

+		if r is not None:

+			return r.east

+

+	@property

+	def northwest(self):

+		r = self.north

+		if r is not None:

+			return r.west

+

+	@property

+	def southeast(self):

+		r = self.south

+		if r is not None:

+			return r.east

+

+	@property

+	def southwest(self):

+		r = self.south

+		if r is not None:

+			return r.west

+

+

+	def __repr__(self):

+		return '%s().set_value(%s)' % (self.__name__, self.value)

+

+	def __str__(self):

+		return str(self.value)

+

+class CellSprite(pygame.sprite.DirtySprite):

+	'''Display code for :py:class:`Cell`'''

+

+	def __init__(self, cell, row, col, *a):

+		self.image = pygame.surface.Surface( (6,6) )

+		self.cell = cell

+		self.row = row

+		self.col = col

+		cell.sprite = self

+		self.spacing = 0

+

+		row, col = self.row, self.col

+		spacing = self.spacing

+		size = width, height = self.image.get_size()

+		self.rect = pygame.rect.Rect( (width*(col)+spacing*(col), (height*(row)+spacing*(row))), size )

+

+		pygame.sprite.DirtySprite.__init__(self, *a)

+		self.start_update(self.cell.value)

+

+

+	colors = {

+		None: (128,128,128),

+		0: (0,0,0),

+		1: (0,255,0),

+		2: (128,64,0),

+		3: (255,0,0)

+	}

+

+	def start_update(self, value):

+		'''Begin to update the cell: store the new value and mark the sprite "dirty"'''

+		self.new_value = value

+		self.dirty = 1

+		self.ud = True

+

+	def update(self):

+		'''Update the cell: set the cell's value and paint the new image'''

+		if self.ud:

+			self.cell.set_value(self.new_value)

+			self.image.fill( self.colors[self.cell.value] )

+

+

+class Board(object):

+	'''Set up and store the cells'''

+

+	def __init__(self, width, height):

+		self.board_group = pygame.sprite.LayeredDirty(_use_update=True)

+		self.rect = pygame.Rect(0,0,0,0)

+		self.dct = {}

+

+		for col in xrange(width):

+			for row in xrange(0,height):

+				cell = self.dct[row, col] = Cell()

+				sprite = CellSprite(cell, row, col, self.board_group)

+

+		for col in xrange(width):

+			for row in xrange(height):

+				cell = self.dct[row,col]

+				cell.east = self.dct.get((row,col+1))

+				cell.south = self.dct.get((row+1,col))

+				cell.autoconnect()

+

+		self.init = self.dct[0,0]

+		self.rect.unionall_ip(list(self.board_group))

+

+

+	def __str__(self):

+		current = self.init

+		result = []

+		while current.east != None:

+			top = current

+			result.append([])

+			while top.south != None:

+				result[-1].append(str(top))

+				top = top.south

+			current = current.east

+		result = zip(*result)

+		return '\n'.join(

+			' '.join(r) for r in result

+		)

+

+import random

+

+

+

+class Controller(object):

+	'''Initialize cell values and run the simulation'''

+	def __init__(self, board):

+		self.board = board

+		self.observers = []

+

+		column = self.board.init

+		for sprite in self.board.board_group:

+			sprite.start_update( random.choice([1]*7+[0]*5 +[2]) )

+		self.board.board_group.update()

+

+

+	def step(self):

+		'''Run one iteration of the simulation'''

+		for observer in self.observers:

+			observer.act()

+

+		c_sprites = pygame.sprite.Group()

+		for sprite in self.board.board_group:

+			cell = sprite.cell

+			nvalue = cell.rule

+			if callable(nvalue):

+				nvalue = nvalue(cell)

+			if nvalue is None:

+				nvalue = cell.value

+			if nvalue != cell.value:

+				sprite.start_update(nvalue)

+				c_sprites.add(sprite)

+		c_sprites.update()

+		return self

+

+	def add_observer(self, cls, *args, **kwargs):

+		'''add an observer to a cell'''

+		observer = cls(*args, **kwargs)

+		self.observers.append(observer)

+		return observer

+

+	def init(self, cb):

+		self.init = cb

+		return self

+

+	def add_event(self, cb):

+		self.events.append(cb)

+		return self

+

+	def loop(self):

+		variables = {}

+		variables.update(self.init())

+		clck = pygame.time.Clock()

+		variables['running'] = True

+

+class Presence(object):

+	'''Observer interface'''

+	def __init__(self, locale):

+		self.locale = locale

+

+	def act(self):

+		'''Override to implement behavior'''

+		pass

+