135 lines
4.5 KiB
Python
135 lines
4.5 KiB
Python
from copy import copy
|
|
from itertools import permutations
|
|
import random
|
|
|
|
|
|
def count( node, states, game, graph ):
|
|
"""Count the number of neighbours in each given states, in a single pass."""
|
|
nb = {s:0 for s in states}
|
|
|
|
for neighbor in graph[node]:
|
|
for state in states:
|
|
if game[neighbor] == state:
|
|
nb[state] += 1
|
|
|
|
# This is the max size of the neighborhood on a rhomb Penrose tiling (P2)
|
|
assert( all(nb[s] <= 11 for s in states) )
|
|
|
|
return nb
|
|
|
|
|
|
class Goucher:
|
|
class State: # Should be an Enum in py3k
|
|
ground = 0
|
|
head = 1
|
|
tail = 2
|
|
wing = 3
|
|
|
|
# Available states, the first one is the default "empty" (or "dead") one.
|
|
states = [ State.ground, State.head, State.tail, State.wing ]
|
|
|
|
def __call__(self, node, current, graph ):
|
|
"""This is the Goucher 4-states rule.
|
|
From: Adam P. Goucher, "Gliders in cellular automata on Penrose tilings", J. Cellular Automata, 2012
|
|
Summarized as:
|
|
------------------------------------------------------
|
|
| Current state | Neighbour condition | Next state |
|
|
------------------------------------------------------
|
|
| 0 | n1>=1 | n2>=1 | * | 3 |
|
|
| 0 | n1>=1 | * | n3>=2 | 3 |
|
|
| 1 | * | * | n3>=1 | 2 |
|
|
| 1 | * | * | * | 1 |
|
|
| 2 | * | * | * | 3 |
|
|
| * | * | * | * | 0 |
|
|
------------------------------------------------------
|
|
"""
|
|
# "a" is just a shortcut.
|
|
a = self.State()
|
|
|
|
# Default state, if nothing matches.
|
|
next = a.ground
|
|
|
|
if current[node] is a.ground:
|
|
# Count the number of neighbors of each state in one pass.
|
|
nb = count( node, [a.head,a.tail,a.wing], current, graph )
|
|
if nb[a.head] >= 1 and nb[a.tail] >= 1:
|
|
next = a.wing
|
|
elif nb[a.head] >= 1 and nb[a.wing] >= 3:
|
|
next = a.wing
|
|
|
|
elif current[node] is a.head:
|
|
# It is of no use to compute the number of heads and tails if the current state is not ground.
|
|
nb = count( node, [a.wing], current, graph )
|
|
if nb[a.wing] >= 1:
|
|
next = a.tail
|
|
else:
|
|
next = a.head
|
|
|
|
elif current[node] is a.tail:
|
|
next = a.wing
|
|
|
|
# Default to ground, as stated above.
|
|
# else:
|
|
# next = a.ground
|
|
|
|
return next
|
|
|
|
|
|
def make_game( graph, state = lambda x: 0 ):
|
|
"""Create a new game board, filled with the results of the calls to the given state function.
|
|
The given graph should be an iterable with all the nodes.
|
|
The given state function should take a node and return a state.
|
|
The default state function returns zero.
|
|
"""
|
|
game = {}
|
|
for node in graph:
|
|
game[node] = state(node)
|
|
return game
|
|
|
|
|
|
def step( current, graph, rule ):
|
|
"""Compute one generation of the game.
|
|
i.e. apply the given rule function on each node of the given graph board.
|
|
The given current board should associate a state to a node.
|
|
The given graph should associate each node with its neighbors.
|
|
The given rule is a function that takes a node, the current board and the graph and return the next state of the node."""
|
|
|
|
# Defaults to the first state of the rule.
|
|
next = make_game(graph, lambda x : rule.states[0])
|
|
|
|
for node in graph:
|
|
next[node] = rule( node, current, graph )
|
|
|
|
return next
|
|
|
|
|
|
def play( game, graph, nb_gen, rule ):
|
|
for i in range(nb_gen):
|
|
game = step( game, graph, rule )
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# Simple demo on a square grid torus.
|
|
graph = {}
|
|
size = 10
|
|
for i in range(size):
|
|
for j in range(size):
|
|
graph[(i,j)] = []
|
|
# 2-permutations of 1-axis neighbors directions == all Moore neighborhood vectors around a coordinate.
|
|
for di,dj in permutations( (-1,0,1), 2 ):
|
|
# Use modulo to avoid limits and create a torus.
|
|
graph[ (i,j) ].append( ( (i+di)%size, (j+dj)%size ) )
|
|
|
|
rule = Goucher()
|
|
# Fill a board with random states.
|
|
game = make_game( graph, lambda x : random.choice(rule.states) )
|
|
|
|
# Play and print.
|
|
for i in range(5):
|
|
print i
|
|
for i in range(size):
|
|
for j in range(size):
|
|
print game[(i,j)],
|
|
print ""
|
|
game = step(game,graph,rule)
|
|
|