# version 0.3

from Tkinter import *
import random

class Automat:

    def __init__(self,n=200,height=300):
        self.worldsize = n
        self.world = [0]*n
        self.root = Tk()
        self.root.title("Lineare Automaten")
        self.height = height
        self.raster = PhotoImage(width=n,height=self.height)
        self.label = Label(self.root,image=self.raster,background="white")
        self.label.pack()
        self.root.update()
        self.line = 0    
        self.colors = ["#ffffff","#ff0000","#00ff00","#0000ff",
                       "#00ffff","#ff00ff","#ffff00","#000000","#80ffff","ff80ff"]

    def setrule(self,numstates,radius,rule):
        self.numstates = numstates
        self.r = radius
        self.newstate=[0]*numstates*(2*radius+1)
        if type(rule)!=type(" "):
            n = ""
            while rule:
                rule,n1 = divmod(rule,self.numstates)
                n = str(n1)+n
            rule = n
        rul1 = list(rule)
        rul1.reverse()
        for z in range(len(rul1)):
            self.newstate[z]=int(rul1[z])

    def setworld(self,worldstring):
        self.world = [0]*self.worldsize
        pos = (self.worldsize-len(worldstring))/2
        for n in range(len(worldstring)):
            w = int(worldstring[n])
            self.world[pos+n] = w

    def randomworld(self):
        self.world = [0]*self.worldsize
        for i in range(self.worldsize):
            self.world[i] = random.randint(0,self.numstates-1)

    def step(self):
        ws = self.worldsize
        w = [0]*ws
        sum = 0
        for x in range(0-self.r,0+self.r+1):
               sum += self.world[x%ws]
        w[0]=self.newstate[sum]
        dx1,dx2 = -self.r-1,self.r
        for x in range(1,self.worldsize):
            sum = sum-self.world[(x+dx1)%ws]+self.world[(x+dx2)%ws]
            w[x] = self.newstate[sum]
        self.world = w

    def display(self):
        if self.line>=self.height:
            self.line = 0
            self.raster.blank()
        for x in range(self.worldsize):
            self.raster.put(self.colors[self.world[x]],(x,self.line))
        self.line += 1
        self.root.update()

                                
    def run(self,n=10):
        for i in range(n):
            self.display()
            self.step()

    def wait(self):
        while 1:
            self.root.update()
        

# eine Gleiterkanone
def demo0():
    a = Automat(500,400)
    a.setrule(2,3,88)
    a.setworld("1111111111011")
    a.run(400)
    a.wait()

# Klasse 1: das Muster entartet homogen
def demo1():
    a = Automat(300,200)
    a.setrule(2,2,0)
    a.randomworld()
    a.run(200)
    a.wait()

# Klasse 2: es bleiben periodische Muster 
def demo2():
    a = Automat(300,200)
    a.setrule(2,2,120)
    a.randomworld()
    a.run(200)
    a.wait()

# Klasse 3: chaotisch unstrukturiert
def demo3():
    a = Automat(300,200)
    a.setrule(3,2,217)
    a.randomworld()
    a.run(200)
    a.wait()

def demo3a():
    a = Automat(300,200)
    a.setrule(2,2,517)
    a.randomworld()
    a.run(200)
    a.wait()

# Klasse 4: komplexe Unterstrukturen
def demo4():
    a = Automat(300,200)
    a.setrule(2,2,20)
    a.randomworld()
    a.run(200)
    a.wait()


# optisch ansprechend 
def demo3b():
    a = Automat(300,200)
    a.setrule(2,2,417)
    a.randomworld()
    a.run(200)
    a.wait()

def demo3c():
    a = Automat(400,300)
    a.setrule(3,1,941)
    a.setworld("100010001")
    a.run(500)
    a.wait()