from Tkinter import *
import os
import pickle
import tkFileDialog as tkfd
import sys
modules=sys.modules

TOPDIR=os.getcwd()
os.chdir('resources')

class GridCanvas(Canvas):
    def __init__(self,boss,width,height,csize,onclic):
        wd=(csize+1)*width-1
        he=(csize+1)*height-1
        Canvas.__init__(self,boss,bg='white',scrollregion=(0,0,wd,he))#,width=wd,height=he)
        self.width=width
        self.height=height
        self.csize=csize
        self.onclic=onclic
        self.bind("<Button-1>",self.clc)

    def dims(self,width,height):
        self.width=width
        self.height=height
        wd=(self.csize+1)*width-1
        he=(self.csize+1)*height-1
        self.configure(scrollregion=(0,0,wd,he))

    def clc(self,event):
        x,y=int(self.canvasx(event.x)),int(self.canvasy(event.y))
        self.onclic(x//(self.csize+1),y//(self.csize+1))

    def draw(self,l,d):
        self.delete(ALL)
        c=self.csize+1
        w=self.width
        h=self.height
        for i in range(len(l)):
            m=l[i]
            if i>=w:
                break
            for j in range(len(m)):
                if j>=h:
                    break
                p=m[j]
                if p!=None:
                    im=p.image(d)
                    self.create_image(i*c+1,j*c+1,image=im,anchor=NW)
        for i in range(w+1):
            self.create_line(i*c,0,i*c,h*c,fill='black')
        for j in range(h+1):
            self.create_line(0,j*c,w*c,j*c,fill='black')


def getclassname(i):
    if hasattr(i,"name"):
        return i.name
    md=i.__module__
    return str(i.__class__)[len(md)+1:]

class Mesecon_conductor(object):
    def __init__(self,connect):
        self.connect=connect
        self.t='conductor'
        self.state=0
        self.connections=[]
        self.group=None

    def get_group(self):
        return self.group


class Mesecon_thing(object):
    def __init__(self,inputs,outputs):
        self.inputs=inputs
        self.outputs=outputs
        self.connections=[[] for i in range(len(outputs))]
        self.ostates=[0]*len(outputs)
        self.istates=[0]*len(inputs)
        self.t='thing'
        self.groups_i=[None]*len(inputs)
        self.groups_o=[None]*len(outputs)

    def reset(self):
        self.isates=[0]*len(self.inputs)

    def get_group_i(self,n):
        return self.groups_i[n]

    def get_group_o(self,n):
        return self.groups_o[n]

    def get_group_r(self,r):
        if r in self.inputs:
            return self.get_group_i(self.inputs.index(r))
        if r in self.outputs:
            return self.get_group_o(self.outputs.index(r))
        return None

    def sig_change(self,inumber,st):
        self.istates[inumber]=st
        self.update_outputs()

    def update_outputs(self):
        pass

    def set_output(self,onum,st):
        if st!=self.ostates[onum]:
            self.ostates[onum]=st
            for reg in self.connections[onum]:
                reg.chst(st)

    def on(self,onumber):
        return self.ostates[onumber]

    def register_connected(self,reg,onumber):
        self.connections[onumber].append(reg)

    def unregister_connected(self,reg,onumber):
        if reg not in self.connections[onumber]:
            return
        self.connections[onumber].remove(reg)

class Mesecons_group(object):
    def __init__(self):
        self.connected=set()
        self.inputs=set()
        self.outputs=set()
        self.psources=0

    def add_conductor(self,c):
        if c not in self.connected:
            self.connected.add(c)
            c.group=self
            return True
        return False

    def add_input(self,i,inumber):
        if (i,inumber) not in self.inputs:
            self.inputs.add((i,inumber))
            i.register_connected(self,inumber)
            i.groups_o[inumber]=self
            if i.on(inumber):
                self.psources+=1
            return True
        return False

    def remove_input(self,i,inumber):
        if (i,inumber) in self.inputs:
            self.inputs.discard((i,inumber))
            i.unregister_connected(self,inumber)
            i.groups_o[inumber]=None
            if i.on(inumber):
                self.psources-=1
                self.update_outputs(self.psources>=1)
                    
    def remove_output(self,o,onumber):
        if (o,onumber) in self.outputs:
            self.outputs.discard((o,onumber))
            o.groups_i[onumber]=None

    def add_output(self,o,onumber):
        if (o,onumber) not in self.outputs:
            self.outputs.add((o,onumber))
            o.groups_i[onumber]=self
            return True
        return False

    def update_outputs(self,st):
        for c in self.connected:
            c.state=st
        for (o,onumber) in self.outputs:
            o.sig_change(onumber,st)

    def chst(self,st):
        ost=(self.psources>=1)
        if st==1:
            self.psources+=1
        else:
            self.psources-=1
        nst=(self.psources>=1)
        if ost!=nst:
            self.update_outputs(nst)

    def has_conductor(self,c):
        return (c in self.connected)

    def has_input(self,i,inum):
        return ((i,inum) in self.inputs)

    def has_output(self,o,onum):
        return ((o,onum) in self.outputs)

    def unreg(self):
        for (i,inum) in self.inputs:
            i.unregister_connected(self,inum)

    def merge(self,other):
        if other is self:
            return
        for (i,inum) in other.inputs:
            i.unregister_connected(other,inum)
            self.add_input(i,inum)
        #self.psources+=other.psources
        self.outputs.update(other.outputs)
        for (o,onum) in other.outputs:
            o.groups_i[onum]=self
        self.connected.update(other.connected)
        for c in other.connected:
            c.group=self
        st=(self.psources>=1)
        self.update_outputs(st)

def iscinl(c,l):
    for i in l:
        if i.has_conductor(c):
            return True
    return False

def isiinl(i,inum,l):
    for k in l:
        if k.has_input(i,inum):
            return True
    return False

def isoinl(o,onum,l):
    for k in l:
        if k.has_output(o,onum):
            return True
    return False

def group_mesecons(l):
    mg=[]
    for z in enum(l):
        if z:
            if z.t=='conductor':
                z.state=0
                z.connections=[]
            elif z.t=="thing":
                z.connections=[[] for i in range(len(z.outputs))]
                z.ostates=[0]*len(z.outputs)
                z.istates=[0]*len(z.inputs)
    for x in range(len(l)):
        m=l[x]
        for y in range(len(m)):
            n=m[y]
            for z in range(len(n)):
                p=n[z]
                if p:
                    if p.t=='conductor':
                        if iscinl(p,mg):
                            continue
                        gr=Mesecons_group()
                        gr.add_conductor(p)
                        mg.append(gr)
                        group_expand(gr,l,x,y,z,p.connect,p.connections)
                    elif p.t=='thing':
                        for inum in range(len(p.outputs)):
                            i=p.outputs[inum]
                            if isiinl(p,inum,mg):
                                continue
                            gr=Mesecons_group()
                            gr.add_input(p,inum)
                            mg.append(gr)
                            group_expand(gr,l,x,y,z,[i])
                        for onum in range(len(p.inputs)):
                            o=p.inputs[onum]
                            if isoinl(p,onum,mg):
                                continue
                            gr=Mesecons_group()
                            gr.add_output(p,onum)
                            mg.append(gr)
                            group_expand(gr,l,x,y,z,[o])
    return mg

def group_expand(gr,l,x,y,z,rls,toadd=[]):
    for r in rls:
        nx,ny,nz=x+r[0],y+r[1],z+r[2]
        if nx<0 or ny<0 or nz<0:
            continue
        try:
            p=l[nx][ny][nz]
        except IndexError:
            continue
        tf=[-r[0],-r[1],-r[2]]
        if p:
            if p.t=='conductor':
                if tf in p.connect:
                    if tf not in p.connections:
                        p.connections.append(tf)
                    if r not in toadd:
                        toadd.append(r)
                    if gr.add_conductor(p):
                        group_expand(gr,l,nx,ny,nz,p.connect,p.connections)
            if p.t=='thing':
                for inum in range(len(p.outputs)):
                    i=p.outputs[inum]
                    if tf == i:
                        if r not in toadd:
                            toadd.append(r)
                        gr.add_input(p,inum)
                for onum in range(len(p.inputs)):
                    o=p.inputs[onum]
                    if tf == o:
                        if r not in toadd:
                            toadd.append(r)
                        gr.add_output(p,onum)

def actpos(l,x,y,z,rls,toadd=[]):
    for r in rls:
        nx,ny,nz=x+r[0],y+r[1],z+r[2]
        if nx<0 or ny<0 or nz<0:
            continue
        try:
            p=l[nx][ny][nz]
        except IndexError:
            continue
        tf=[-r[0],-r[1],-r[2]]
        if p:
            if p.t=='conductor':
                if tf in p.connect:
                    if tf not in p.connections:
                        p.connections.append(tf)
                    if r not in toadd:
                        toadd.append(r)
            if p.t=='thing':
                for inum in range(len(p.outputs)):
                    i=p.outputs[inum]
                    if tf == i:
                        if r not in toadd:
                            toadd.append(r)
                for onum in range(len(p.inputs)):
                    o=p.inputs[onum]
                    if tf == o:
                        if r not in toadd:
                            toadd.append(r)

def rempos(l,x,y,z,rls,toadd):
    for r in rls:
        nx,ny,nz=x+r[0],y+r[1],z+r[2]
        if nx<0 or ny<0 or nz<0:
            continue
        try:
            p=l[nx][ny][nz]
        except IndexError:
            continue
        tf=[-r[0],-r[1],-r[2]]
        if p:
            if p.t=='conductor':
                if tf in p.connections:
                    p.connections.remove(tf)
                    if r not in toadd:
                        toadd.append(r)
            elif p.t=='thing':
                if tf in p.inputs+p.outputs:
                    if r not in toadd:
                        toadd.append(r)

def rules(x):
    if x.t=='conductor':
        return x.connect
    elif x.t=='thing':
        return x.inputs+x.outputs
    else:
        return []

def enum(l):
    for i in l:
        for j in i:
            for k in j:
                yield k

def update_group(l,x,y,z,r,g,gin=[]):
    nx,ny,nz=x+r[0],y+r[1],z+r[2]
    o=l[nx][ny][nz]
    if o.t=="conductor":
        og=o.get_group()
        if og not in gin:
            g.merge(og)
            gin.append(og)
    elif o.t=='thing':
        nr=[-r[0],-r[1],-r[2]]
        og=o.get_group_r(nr)
        if og not in gin:
            g.merge(og)
            gin.append(og)

def rotate_rule(rule):
    return [rule[2], rule[1], -rule[0]]

def rotate_left(rules):
    return [rotate_rule(rule) for rule in rules]

def rotate_left_n(rules,n):
    for i in range(n):
        rules=rotate_left(rules)
    return rules

"""class Test1(Mesecon_conductor):
    def __init__(self):
        Mesecon_conductor.__init__(self,[[0,0,1],[0,0,-1],[0,1,0],[0,-1,0]])

class Test2(Mesecon_thing):
    def __init__(self):
        Mesecon_thing.__init__(self,[[[0,0,-1]]],[[[0,1,0]]])

    def update_outputs(self):
        self.set_output(0,1-self.istates[0])


tbl=[[[Test1(),Test1(),Test2()],[None,None,Test1()],[None,None,Test1()]]]
mg=group_mesecons(tbl)
mg[0].update_outputs(0)
print mg
print mg[1].psources
print tbl[0][0][2].connections
"""        
class Application:
    def __init__(self,maxc=10):
        self.tk=Tk()
        self.tk.title("Mesecons simulator")
        self.used=0
        self.btsframe=Frame(self.tk)
        self.btsframe.grid(row=0,column=0,columnspan=2,sticky=W)
        self.levlbl=Label(self.tk, text="Plane: XZ, Y-Level: 0")
        self.levlbl.grid(row=1,column=0,columnspan=2,sticky=W)
        self.can=GridCanvas(self.tk,maxc,maxc,30,self.clic)
        self.can.grid(row=2,column=0,sticky=NSEW)
        self.xsc=Scrollbar(self.tk,command=self.can.xview, orient=HORIZONTAL)
        self.xsc.grid(row=3,column=0,sticky=EW)
        self.can.configure(xscrollcommand=self.xsc.set)
        self.ysc=Scrollbar(self.tk,command=self.can.yview, orient=VERTICAL)
        self.ysc.grid(row=2,column=1,sticky=NS)
        self.can.configure(yscrollcommand=self.ysc.set)
        self.tk.grid_rowconfigure(2,weight=1)
        self.tk.grid_columnconfigure(0,weight=1)
        self.l=[[[None]*maxc for i in range(maxc)] for i in range(maxc)]
        self.maxcoords=(maxc,maxc,maxc)
        self.curplane=(1,0) #plane (x,z) at y level 0
        self.can.draw(self.l[0],0)
        self.abms=[]
        self.abm_gen=0
        self.abm()
        self.tk.bind("<z>",self.levup)
        self.tk.bind("<s>",self.levdown)
        self.tk.bind("<r>",self.rotate)
        self.tk.bind("<Control-o>",self.open_command)
        self.tk.bind("<Control-s>",self.save_command)

    def abm(self):
        self.abm_gen+=1
        for c,t in self.abms:
            if self.abm_gen%t==0:
                c()
        self.draw()
        self.tk.after(100,self.abm)

    def register_abm(self,c,t):
        if (c,t) not in self.abms:
            self.abms.append((c,t))

    def unregister_abm(self,c,t):
        if (c,t) in self.abms:
            self.abms.remove((c,t))

    def rotate(self,evnt):
        d=(self.curplane[0]+1)%3
        l=min(self.maxcoords[d],self.curplane[1])
        self.curplane=(d,l)
        self.uplbl()
        self.draw()

    def levup(self,evnt):
        self.curplane=(self.curplane[0],min(self.maxcoords[self.curplane[0]]-1,self.curplane[1]+1))
        self.uplbl()
        self.draw()

    def levdown(self,evnt):
        self.curplane=(self.curplane[0],max(0,self.curplane[1]-1))
        self.uplbl()
        self.draw()

    def uplbl(self):
        d,l=self.curplane
        if d==0:
            t="Plane: YZ, X-Level: "
        elif d==1:
            t="Plane: XZ, Y-Level: "
        else:
            t="Plane: XY, Z-Level: "
        t+=str(l)
        self.levlbl.configure(text=t)

    def persistent_id(self,obj):
        if obj is self:
            return 'self'
        return None

    def persistent_load(self,id):
        return self

    def save(self,fname):
        f=open(fname,'w')
        p=pickle.Pickler(f)
        p.persistent_id=self.persistent_id
        p.dump(self.l)
        f.close()

    def open_(self,fname):
        f=open(fname,'r')
        p=pickle.Unpickler(f)
        p.persistent_load=self.persistent_load
        self.l=p.load()
        f.close()
        self.draw()

    def open_command(self,event=None):
        op=tkfd.Open(self.tk).show()
        if op:
            self.open_(op)

    def save_command(self,event=None):
        sa=tkfd.SaveAs(self.tk).show()
        if sa:
            self.save(sa)
        

    def mainloop(self):
        self.tk.mainloop()

    def get_real_coords(self,x,y):
        d=self.curplane[0]
        level=self.curplane[1]
        if d==0:
            return level,self.maxcoords[1]-y-1,x
        elif d==1:
            return x,level,y
        else:
            return x,self.maxcoords[1]-y-1,level

    def chpos(self,x,y,z,new):
        a=self.l[x][y][z]
        if a:
            l=[]
            rempos(self.l,x,y,z,rules(a),l)
            self.l[x][y][z]=None
            if a.t=='thing':
                for i in range(len(a.inputs)):
                    g=a.get_group_i(i)
                    g.remove_output(a,i)
                for o in range(len(a.outputs)):
                    g=a.get_group_o(o)
                    g.remove_input(a,o)
            elif a.t=="conductor":
                g=a.get_group()
                g.unreg()
                gs=[]
                for r in l:
                    nx,ny,nz=x+r[0],y+r[1],z+r[2]
                    nr=[-r[0],-r[1],-r[2]]
                    np=self.l[nx][ny][nz]
                    g=Mesecons_group()
                    gs.append(g)
                    if np.t=='conductor':
                        g.add_conductor(np)
                        group_expand(g,self.l,nx,ny,nz,np.connect)
                    elif np.t=='thing':
                        if nr in np.inputs:
                            i=np.inputs.index(nr)
                            g.add_output(np,i)
                        elif nr in np.outputs:
                            i=np.outputs.index(nr)
                            g.add_input(np,i)
                    for g in gs:
                        g.update_outputs(g.psources>=1)
            del a

        self.l[x][y][z]=new
        if new!=None:
            if new.t=="conductor":
                l=[]
                actpos(self.l,x,y,z,new.connect,l)
                g=Mesecons_group()
                g.add_conductor(new)
                new.connections=l
                gin=[]
                for r in l:
                    update_group(self.l,x,y,z,r,g,gin)
            elif new.t=="thing":
                l=[]
                actpos(self.l,x,y,z,new.inputs+new.outputs,l)
                igs=[Mesecons_group() for i in range(len(new.inputs))]
                ogs=[Mesecons_group() for i in range(len(new.outputs))]
                for i in range(len(new.inputs)):
                    igs[i].add_output(new,i)
                    g=igs[i]
                    r=new.inputs[i]
                    if r in l:
                        update_group(self.l,x,y,z,r,g)
                        if g.psources>=1:
                            new.istates[i]=1
                        else:
                            new.istates[i]=0
                for i in range(len(new.outputs)):
                    ogs[i].add_input(new,i)
                    g=ogs[i]
                    r=new.outputs[i]
                    if r in l:
                        update_group(self.l,x,y,z,r,g)
                new.update_outputs()

    def addcells(self):
        w=Toplevel(self.tk)
        self.w=w
        w.title("Add cells")
        l=[]
        t=Label(w,text="Add cells:")
        t.grid(row=0,column=0,columnspan=3,sticky=W)
        for (i,d) in enumerate(("X","Y","Z")):
            txt1=Label(w,text="%s-axis: Before:"%d)
            txt1.grid(row=2*i+1,column=0,sticky=E)
            txt2=Label(w,text="After:")
            txt2.grid(row=2*i+2,column=0,sticky=E)
            sp1=Spinbox(w,from_=0,to=1000)
            sp1.grid(row=2*i+1,column=1,columnspan=2)
            sp2=Spinbox(w,from_=0,to=1000)
            sp2.grid(row=2*i+2,column=1,columnspan=2)
            l.append((sp1,sp2))
        self.sps=l
        bt=Button(w,text='OK',command=self.addok)
        bt.grid(row=7,column=2,sticky=E)
        btc=Button(w,text='Cancel',command=w.destroy)
        btc.grid(row=7,column=0,sticky=W)
        w.bind("<Button-1>",self.addclic)

    def addclic(self,ev):
        def update_spin(x):
            v=x.get()
            s=""
            for k in v:
                if k in "0123456789":
                    s+=k
            x.delete(0,END)
            x.insert(0,s)
        for sp1,sp2 in self.sps:
            update_spin(sp1)
            update_spin(sp2)

    def addok(self):
        def toint(i):
            s=""
            for k in i:
                if k in "0123456789":
                    s+=k
            return int(s)
        l=[]
        for sp1,sp2 in self.sps:
            l.append((toint(sp1.get()),toint(sp2.get())))
        self.l=[[[None]*self.maxcoords[2]
                 for j in range(self.maxcoords[1])]
                for i in range(l[0][0])]+\
                self.l+\
                [[[None]*self.maxcoords[2]
                  for j in range(self.maxcoords[1])]
                 for i in range(l[0][1])]
        mx0=self.maxcoords[0]+l[0][0]+l[0][1]
        self.l=[[[None]*self.maxcoords[2] for j in range(l[1][0])]+
                i+
                [[None]*self.maxcoords[2] for j in range(l[1][1])]
                for i in self.l]
        mx1=self.maxcoords[1]+l[1][0]+l[1][1]
        self.l=[[[None]*l[2][0]+
                 j+[None]*l[2][1] for j in i]
                for i in self.l]
        mx2=self.maxcoords[2]+l[2][0]+l[2][1]
        self.maxcoords=mx0,mx1,mx2
        self.w.destroy()
        for i in enum(self.l):
            if hasattr(i,'update_pos'):
                i.update_pos(l[0][0],l[1][0],l[2][0])
        self.draw()

    def stats(self):
        dic={}
        for i in enum(self.l):
            if i!=None:
                name=getclassname(i)
                d=dic.get(name,0)+1
                dic[name]=d
        w=Toplevel(self.tk)
        w.title("Statistics")
        txt="\n - ".join(["%s:%s"%i for i in dic.items()])
        if txt=="":
            txt="Nothing"
        lbl=Label(w,text="Your machine uses:\n - "+txt,justify=LEFT)
        lbl.pack()
        Button(w,text="OK",command=w.destroy).pack()
        
    def set_buttons(self,*b):
        a=Button(self.btsframe,bg='white',image=ADDCELLS,command=self.addcells)
        a.pack(side=LEFT)
        a=Button(self.btsframe,bg='white',image=STATS,command=self.stats)
        a.pack(side=LEFT)
        b=[None,None,None]+list(b)
        self.bts=[]
        self.nodes=b
        for i in range(len(b)):
            if i==0:
                a=Button(self.btsframe,bg='white',image=POINTER,command=lambda i=i:self.set_used(i),relief=SUNKEN)
            elif i==2:
                a=Button(self.btsframe,bg='white',image=ERASER,command=lambda i=i:self.set_used(i))
            elif i==1:
                a=Button(self.btsframe,bg='white',image=ROTATE,command=lambda i=i:self.set_used(i))
            else:
                a=Button(self.btsframe,bg='white',image=b[i].imagedraw(),command=lambda i=i:self.set_used(i))
            self.bts.append(a)
            a.pack(side=LEFT)

    def set_used(self,i):
        self.bts[self.used].configure(relief=RAISED)
        self.used=i
        self.bts[i].configure(relief=SUNKEN)
        
    def clic(self,x,y):
        try:
            x,y,z=self.get_real_coords(x,y)
            if x>=self.maxcoords[0] or y>=self.maxcoords[1] or z>=self.maxcoords[2]:
                return
            if self.used>1:
                cl=self.nodes[self.used]
                if self.l[x][y][z] and self.l[x][y][z].t=="unremovable":
                    return
                if hasattr(self.l[x][y][z],"onremove"):
                    self.l[x][y][z].onremove()
                if cl==None:
                    self.chpos(x,y,z,None)
                else:
                    self.chpos(x,y,z,cl(self,x,y,z))
            elif self.used==0:
                p=self.l[x][y][z]
                if hasattr(p,'action'):
                        p.action()
            else:
                p=self.l[x][y][z]
                if hasattr(p,'rotate'):
                    self.chpos(x,y,z,p.rotate(self,x,y,z))
            self.draw()
        except RuntimeError:
            print "Warning : will cause stack overflow"

    def getplane(self,plane):
        level=plane[1]
        d=plane[0]
        if d==0:
            return [[j[k] for j in reversed(self.l[level])] for k in range(len(self.l[0][0]))]
        elif d==1:
            return [i[level] for i in self.l]
        else:
            return [[j[level] for j in reversed(i)] for i in self.l]

    def canreconf(self):
        d=self.curplane[0]
        if d==0:
            x,y=self.maxcoords[2],self.maxcoords[1]
        elif d==1:
            x,y=self.maxcoords[0],self.maxcoords[2]
        else:
            x,y=self.maxcoords[0],self.maxcoords[1]
        self.can.dims(x,y)

    def draw(self):
        m=self.getplane(self.curplane)
        self.canreconf()
        self.can.draw(m,self.curplane[0])        

a=Application(20)

ADDCELLS=PhotoImage(file='addcells.gif')
STATS=PhotoImage(file='stats.gif')
ERASER=PhotoImage(file='eraser.gif')
POINTER=PhotoImage(file='pointer.gif')
ROTATE=PhotoImage(file='rotate.gif')

default_rules=[[0,0,1],[0,0,-1],[1,0,0],[-1,0,0],[0,-1,1],[0,-1,-1],
               [1,-1,0],[-1,-1,0],[0,1,1],[0,1,-1],[1,1,0],[-1,1,0]]


class Normal_block(object):
    p=PhotoImage(file="normal.gif")
    t="normal"
    name="Normal block"
    def __init__(self,boss,x,y,z):
        pass

    def image(self,d):
        return self.p
    
    @classmethod
    def imagedraw(cls):
        return cls.p


class Mesecon(Mesecon_conductor):
    #p=[PhotoImage(file='moff.gif'),PhotoImage(file='mon.gif')]
    p=[[PhotoImage(file='moff'+str(i)+'.gif') for i in range(24)],
       [PhotoImage(file='mon'+str(i)+'.gif') for i in range(24)]]
    name="Mesecon"
    def __init__(self,boss,x,y,z):
        Mesecon_conductor.__init__(self,default_rules)

    def image(self,d):
        if d==1: #Y-plane
            k=-1
            if [0,0,1] in self.connections or [0,-1,1] in self.connections or [0,1,1] in self.connections:
                k+=1
            if [0,0,-1] in self.connections or [0,-1,-1] in self.connections or [0,1,-1] in self.connections:
                k+=2
            if [1,0,0] in self.connections or [1,-1,0] in self.connections or [1,1,0] in self.connections:
                k+=4
            if [-1,0,0] in self.connections or [-1,-1,0] in self.connections or [-1,1,0] in self.connections:
                k+=8
            if k==-1:
                k=14
        elif d==0:
            k=15
            if [0,1,1] in self.connections:
                k+=6
            elif [0,0,1] in self.connections or [0,-1,1] in self.connections:
                k+=3
            if [0,1,-1] in self.connections:
                k+=2
            elif [0,0,-1] in self.connections or [0,-1,-1] in self.connections:
                k+=1
        elif d==2:
            k=15
            if [1,1,0] in self.connections:
                k+=6
            elif [1,0,0] in self.connections or [1,-1,0] in self.connections:
                k+=3
            if [-1,1,0] in self.connections:
                k+=2
            elif [-1,0,0] in self.connections or [-1,-1,0] in self.connections:
                k+=1
        return self.p[self.state][k]

    @classmethod
    def imagedraw(cls):
        return cls.p[0][14]

class Switch(Mesecon_thing):
    name="Switch"
    p=[PhotoImage(file='switch_off.gif'),PhotoImage(file='switch_on.gif')]
    def __init__(self,boss,x,y,z):
        Mesecon_thing.__init__(self,[],default_rules)

    def image(self,d):
        return self.p[self.ostates[0]]

    @classmethod
    def imagedraw(cls):
        return cls.p[0]

    def action(self):
        st=1-self.ostates[0]
        for i in range(len(self.ostates)):
            self.set_output(i,st)

class RedLightStone(Mesecon_thing):
    name="Red Lightstone"
    p=[PhotoImage(file='red_lightstone_off.gif'),
       PhotoImage(file='red_lightstone_on.gif')]
    def __init__(self,boss,x,y,z):
        Mesecon_thing.__init__(self,default_rules,[])
        self.st=0

    def image(self,d):
        return self.p[self.st]

    @classmethod
    def imagedraw(cls):
        return cls.p[0]

    def update_outputs(self):
        self.st=(sum(self.istates)>=1)

class Sand(object):
    name="Sand"
    t="sand"
    p=PhotoImage(file='sand.gif')
    def __init__(self,boss,x,y,z):
        self.boss=boss
        self.x,self.y,self.z=x,y,z
        self.boss.register_abm(self.abm,1)

    def image(self,d):
        return self.p

    @classmethod
    def imagedraw(cls):
        return cls.p

    def abm(self):
        if self.y==0:
            return
        below=self.boss.l[self.x][self.y-1][self.z]
        if below==None:
            self.boss.chpos(self.x,self.y-1,self.z,self)
            self.boss.chpos(self.x,self.y,self.z,None)
            self.y-=1
            if self.y<self.boss.maxcoords[1]-2:
                above=self.boss.l[self.x][self.y+2][self.z]
                if above and above.t=="sand":
                    above.abm()

    def update_pos(self,xadd,yadd,zadd):
        self.x+=xadd
        self.y+=yadd
        self.z+=zadd

    def onremove(self):
        self.boss.unregister_abm(self.abm,1)
            
class ClassContainer:
    pass

def rotated(t,mx):
    l=[]
    for i in range(mx):
        th=t(i)
        l.append(th)
        setattr(ClassContainer,th.__name__+str(i),th)
        setattr(modules["__main__"],"ClassContainer."+th.__name__+str(i),th)
        th.__name__="ClassContainer."+th.__name__+str(i)
    for i in range(mx):
        l[i].rotate=l[(i+1)%mx]
    return l[0]

def Inverter(i):
    rin=rotate_left_n([[0,0,1]],i)
    rout=rotate_left_n([[0,0,-1]],i)
    class _Inverter(Mesecon_thing):
        name="Inverter gate"
        p=[[PhotoImage(file='inverter_side_%s_off.gif'%((i+1)%4)),
            PhotoImage(file='inverter_%s_off.gif'%i),
            PhotoImage(file='inverter_side_%s_off.gif'%((-i+2)%4))],
           [PhotoImage(file='inverter_side_%s_on.gif'%((i+1)%4)),
            PhotoImage(file='inverter_%s_on.gif'%i),
            PhotoImage(file='inverter_side_%s_on.gif'%((-i+2)%4))]]
        def __init__(self,boss,x,y,z):
            Mesecon_thing.__init__(self,rin,rout)

        def image(self,d):
            return self.p[self.ostates[0]][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][1]

        def update_outputs(self):
            self.set_output(0,not self.istates[0])
    return _Inverter

def Diode(i):
    rin=rotate_left_n([[0,0,1]],i)
    rout=rotate_left_n([[0,0,-1]],i)
    class _Diode(Mesecon_thing):
        name="Diode gate"
        p=[[PhotoImage(file='diode_side_%s_off.gif'%((i+1)%4)),
            PhotoImage(file='diode_%s_off.gif'%i),
            PhotoImage(file='diode_side_%s_off.gif'%((-i+2)%4))],
           [PhotoImage(file='diode_side_%s_on.gif'%((i+1)%4)),
            PhotoImage(file='diode_%s_on.gif'%i),
            PhotoImage(file='diode_side_%s_on.gif'%((-i+2)%4))]]
        def __init__(self,boss,x,y,z):
            Mesecon_thing.__init__(self,rin,rout)

        def image(self,d):
            return self.p[self.ostates[0]][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][1]

        def update_outputs(self):
            self.set_output(0,self.istates[0])
    return _Diode

def And(i):
    rin=rotate_left_n([[1,0,0],[-1,0,0]],i)
    rout=rotate_left_n([[0,0,-1]],i)
    class _And(Mesecon_thing):
        name="And gate"
        p=[[PhotoImage(file='and_side_%s_off.gif'%((i+1)%4)),
            PhotoImage(file='and_%s_off.gif'%i),
            PhotoImage(file='and_side_%s_off.gif'%((-i+2)%4))],
           [PhotoImage(file='and_side_%s_on.gif'%((i+1)%4)),
            PhotoImage(file='and_%s_on.gif'%i),
            PhotoImage(file='and_side_%s_on.gif'%((-i+2)%4))]]
        def __init__(self,boss,x,y,z):
            Mesecon_thing.__init__(self,rin,rout)

        def image(self,d):
            return self.p[self.ostates[0]][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][1]

        def update_outputs(self):
            self.set_output(0,self.istates[0] and self.istates[1])
    return _And

def Nand(i):
    rin=rotate_left_n([[1,0,0],[-1,0,0]],i)
    rout=rotate_left_n([[0,0,-1]],i)
    class _Nand(Mesecon_thing):
        name="Nand gate"
        p=[[PhotoImage(file='nand_side_%s_off.gif'%((i+1)%4)),
            PhotoImage(file='nand_%s_off.gif'%i),
            PhotoImage(file='nand_side_%s_off.gif'%((-i+2)%4))],
           [PhotoImage(file='nand_side_%s_on.gif'%((i+1)%4)),
            PhotoImage(file='nand_%s_on.gif'%i),
            PhotoImage(file='nand_side_%s_on.gif'%((-i+2)%4))]]
        def __init__(self,boss,x,y,z):
            Mesecon_thing.__init__(self,rin,rout)

        def image(self,d):
            return self.p[self.ostates[0]][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][1]

        def update_outputs(self):
            self.set_output(0,not(self.istates[0] and self.istates[1]))
    return _Nand

def Xor(i):
    rin=rotate_left_n([[1,0,0],[-1,0,0]],i)
    rout=rotate_left_n([[0,0,-1]],i)
    class _Xor(Mesecon_thing):
        name="Xor gate"
        p=[[PhotoImage(file='xor_side_%s_off.gif'%((i+1)%4)),
            PhotoImage(file='xor_%s_off.gif'%i),
            PhotoImage(file='xor_side_%s_off.gif'%((-i+2)%4))],
           [PhotoImage(file='xor_side_%s_on.gif'%((i+1)%4)),
            PhotoImage(file='xor_%s_on.gif'%i),
            PhotoImage(file='xor_side_%s_on.gif'%((-i+2)%4))]]
        def __init__(self,boss,x,y,z):
            Mesecon_thing.__init__(self,rin,rout)

        def image(self,d):
            return self.p[self.ostates[0]][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][1]

        def update_outputs(self):
            self.set_output(0,self.istates[0]^self.istates[1])
    return _Xor

def Insulated(i):
    rs=rotate_left_n([[1,0,0],[-1,0,0]],i)
    class _Insulated(Mesecon_conductor):
        name="Insulated wire"
        p=[[PhotoImage(file='insulated_side_%s_off.gif'%((i+1)%2)),
            PhotoImage(file='insulated_%s.gif'%i),
            PhotoImage(file='insulated_side_%s_off.gif'%i)],
           [PhotoImage(file='insulated_side_%s_on.gif'%((i+1)%2)),
            PhotoImage(file='insulated_%s.gif'%i),
            PhotoImage(file='insulated_side_%s_on.gif'%i)]]
        def __init__(self,boss,x,y,z):
            Mesecon_conductor.__init__(self,rs)

        def image(self,d):
            return self.p[self.state][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][1]
    return _Insulated

def Insulated_t(i):
    rs=rotate_left_n([[1,0,0],[-1,0,0],[0,0,1]],i)
    class _Insulated_t(Mesecon_conductor):
        name="Insulated T-junction"
        p=[[PhotoImage(file='insulated_t_side_%s_off.gif'%((i+1)%4)),
            PhotoImage(file='insulated_t_%s.gif'%i),
            PhotoImage(file='insulated_t_side_%s_off.gif'%((-i+2)%4))],
           [PhotoImage(file='insulated_t_side_%s_on.gif'%((i+1)%4)),
            PhotoImage(file='insulated_t_%s.gif'%i),
            PhotoImage(file='insulated_t_side_%s_on.gif'%((-i+2)%4))]]
        def __init__(self,boss,x,y,z):
            Mesecon_conductor.__init__(self,rs)

        def image(self,d):
            return self.p[self.state][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][1]
    return _Insulated_t

def Delayer(i):
    rin=rotate_left_n([[0,0,1]],i)
    rout=rotate_left_n([[0,0,-1]],i)
    class _Delayer(Mesecon_thing):
        name="Delayer"
        p=[[[PhotoImage(file='delayer_%s_%s_off.gif'%(k,(i+1)%4)),
            PhotoImage(file='delayer_%s_%s_off.gif'%(k,i)),
            PhotoImage(file='delayer_%s_%s_off.gif'%(k,(-i+2)%4))],
           [PhotoImage(file='delayer_%s_%s_on.gif'%(k,(i+1)%4)),
            PhotoImage(file='delayer_%s_%s_on.gif'%(k,i)),
            PhotoImage(file='delayer_%s_%s_on.gif'%(k,(-i+2)%4))]] for k in range(4)]
        def __init__(self,boss,x,y,z):
            Mesecon_thing.__init__(self,rin,rout)
            self.boss=boss
            self.timer=0

        def image(self,d):
            return self.p[self.timer][self.ostates[0]][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][0][1]

        def action(self):
            self.timer=(self.timer+1)%4

        def update_outputs(self):
            tps=[100,300,500,1000][self.timer]
            st=self.istates[0]
            self.boss.tk.after(tps,lambda st=st: self.set_output(0,st))
    return _Delayer

def piston_rules(rs):
    return [i for i in default_rules if i!=rs]

def Piston_all(rs,plst):
    class _Piston(Mesecon_thing):
        name="Piston"
        p=[[PhotoImage(file='piston_%s_off.gif'%plst[0]),
            PhotoImage(file='piston_%s_off.gif'%plst[1]),
            PhotoImage(file='piston_%s_off.gif'%plst[2])],
           [PhotoImage(file='piston_%s_on.gif'%plst[0]),
            PhotoImage(file='piston_%s_on.gif'%plst[1]),
            PhotoImage(file='piston_%s_on.gif'%plst[2])]]
        def __init__(self,boss,x,y,z):
            Mesecon_thing.__init__(self,piston_rules(rs),[])
            self.x,self.y,self.z,self.boss=x,y,z,boss
            self.st=False
            self.unpushable=False

        def update_pos(self,xadd,yadd,zadd):
            self.x+=xadd
            self.y+=yadd
            self.z+=zadd

        def image(self,d):
            return self.p[self.st][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][1]

        def update_outputs(self):
            l=[]
            st=(sum(self.istates)>=1)
            if (st and self.st) or ((not st) and (not self.st)):
                return
            self.st=st
            if self.st:
                can=False
                for i in range(1,15):
                    posx,posy,posz=self.x+rs[0]*i,self.y+rs[1]*i,self.z+rs[2]*i
                    p=self.boss.l[posx][posy][posz]
                    if p==None:
                        break
                    elif (hasattr(p,"unpushable") and p.unpushable):
                        can=True
                        break
                    else:
                        l.append(p)
                else:
                    self.st=0
                    self.unpushable=False
                    return
                if can:
                    self.st=0
                    self.unpushable=True
                    return
                posx,posy,posz=self.x+rs[0],self.y+rs[1],self.z+rs[2]
                self.boss.chpos(posx,posy,posz,_Piston_Head())
                for i in range(len(l)):
                    posx,posy,posz=self.x+rs[0]*(i+2),self.y+rs[1]*(i+2),self.z+rs[2]*(i+2)
                    self.boss.chpos(posx,posy,posz,None)
                for i in range(len(l)):
                    p=l[i]
                    if hasattr(p,'update_pos'):
                        p.update_pos(rs[0],rs[1],rs[2])
                    if p.t=="thing":
                        p.reset()
                    posx,posy,posz=self.x+rs[0]*(i+2),self.y+rs[1]*(i+2),self.z+rs[2]*(i+2)
                    self.boss.chpos(posx,posy,posz,p)
            else:
                posx,posy,posz=self.x+rs[0],self.y+rs[1],self.z+rs[2]
                self.boss.chpos(posx,posy,posz,None)
            self.unpushable=self.st
                
        def onremove(self):
            if self.st:
                posx,posy,posz=self.x+rs[0],self.y+rs[1],self.z+rs[2]
                self.boss.chpos(posx,posy,posz,None)
        
    class _Piston_Head(object):
        name="Piston head"
        p=[PhotoImage(file='piston_head_%s.gif'%plst[0]),
            PhotoImage(file='piston_head_%s.gif'%plst[1]),
            PhotoImage(file='piston_head_%s.gif'%plst[2])]
        t="unremovable"
        unpushable=True
        def __init__(self):
            pass

        def image(self,d):
            return self.p[d]
        
    return _Piston

def Piston(i):
    plst=[[5,1,1],[3,2,4],[4,3,3],[1,0,5]][i]
    return Piston_all(rotate_left_n([[1,0,0]],i)[0],plst)

Piston_Up=Piston_all([0,1,0],[2,5,2])
Piston_Up.__name__='Piston_Up'
Piston_Down=Piston_all([0,-1,0],[0,4,0])
Piston_Down.__name__='Piston_Down'

def Sticky_Piston_all(rs,plst):
    class _Sticky_Piston(Mesecon_thing):
        name="Sticky piston"
        p=[[PhotoImage(file='sticky_piston_%s_off.gif'%plst[0]),
            PhotoImage(file='sticky_piston_%s_off.gif'%plst[1]),
            PhotoImage(file='sticky_piston_%s_off.gif'%plst[2])],
           [PhotoImage(file='sticky_piston_%s_on.gif'%plst[0]),
            PhotoImage(file='sticky_piston_%s_on.gif'%plst[1]),
            PhotoImage(file='sticky_piston_%s_on.gif'%plst[2])]]
        def __init__(self,boss,x,y,z):
            Mesecon_thing.__init__(self,piston_rules(rs),[])
            self.x,self.y,self.z,self.boss=x,y,z,boss
            self.st=False
            self.unpushable=False

        def update_pos(self,xadd,yadd,zadd):
            self.x+=xadd
            self.y+=yadd
            self.z+=zadd

        def image(self,d):
            return self.p[self.st][d]

        @classmethod
        def imagedraw(cls):
            return cls.p[0][1]

        def update_outputs(self):
            l=[]
            st=(sum(self.istates)>=1)
            if (st and self.st) or ((not st) and (not self.st)):
                return
            self.st=st
            if self.st:
                can=False
                for i in range(1,15):
                    posx,posy,posz=self.x+rs[0]*i,self.y+rs[1]*i,self.z+rs[2]*i
                    p=self.boss.l[posx][posy][posz]
                    if p==None:
                        break
                    elif (hasattr(p,"unpushable") and p.unpushable):
                        can=True
                        break
                    else:
                        l.append(p)
                else:
                    self.st=0
                    self.unpushable=False
                    return
                if can:
                    self.st=0
                    self.unpushable=True
                    return
                posx,posy,posz=self.x+rs[0],self.y+rs[1],self.z+rs[2]
                self.boss.chpos(posx,posy,posz,_Sticky_Piston_Head())
                for i in range(len(l)):
                    posx,posy,posz=self.x+rs[0]*(i+2),self.y+rs[1]*(i+2),self.z+rs[2]*(i+2)
                    self.boss.chpos(posx,posy,posz,None)
                for i in range(len(l)):
                    p=l[i]
                    if hasattr(p,'update_pos'):
                        p.update_pos(rs[0],rs[1],rs[2])
                    if p.t=="thing":
                        p.reset()
                    posx,posy,posz=self.x+rs[0]*(i+2),self.y+rs[1]*(i+2),self.z+rs[2]*(i+2)
                    self.boss.chpos(posx,posy,posz,p)
            else:
                posx2,posy2,posz2=self.x+2*rs[0],self.y+2*rs[1],self.z+2*rs[2]
                posx,posy,posz=self.x+rs[0],self.y+rs[1],self.z+rs[2]
                p=self.boss.l[posx2][posy2][posz2]
                if hasattr(p,'unpushable') and p.unpushable:
                    self.boss.chpos(posx,posy,posz,None)
                else:
                    if hasattr(p,'update_pos'):
                        p.update_pos(-rs[0],-rs[1],-rs[2])
                    if p.t=="thing":
                        p.reset()
                    self.boss.chpos(posx2,posy2,posz2,None)
                    self.boss.chpos(posx,posy,posz,p)
            self.unpushable=self.st
                
        def onremove(self):
            if self.st:
                posx,posy,posz=self.x+rs[0],self.y+rs[1],self.z+rs[2]
                self.boss.chpos(posx,posy,posz,None)
        
    class _Sticky_Piston_Head(object):
        name="Sticky piston head"
        p=[PhotoImage(file='sticky_piston_head_%s.gif'%plst[0]),
            PhotoImage(file='sticky_piston_head_%s.gif'%plst[1]),
            PhotoImage(file='sticky_piston_head_%s.gif'%plst[2])]
        t="unremovable"
        unpushable=True
        def __init__(self):
            pass

        def image(self,d):
            return self.p[d]
        
    return _Sticky_Piston

def Sticky_Piston(i):
    plst=[[5,1,1],[3,2,4],[4,3,3],[1,0,5]][i]
    return Sticky_Piston_all(rotate_left_n([[1,0,0]],i)[0],plst)

Sticky_Piston_Up=Sticky_Piston_all([0,1,0],[2,5,2])
Sticky_Piston_Up.__name__='Sticky_Piston_Up'
Sticky_Piston_Down=Sticky_Piston_all([0,-1,0],[0,4,0])
Sticky_Piston_Down.__name__='Sticky_Piston_Down'

Inverters=rotated(Inverter,4)
t=Inverters(0,0,0,0)
Diodes=rotated(Diode,4)
Ands=rotated(And,4)
Nands=rotated(Nand,4)
Xors=rotated(Xor,4)
Insulateds=rotated(Insulated,2)
Insulated_ts=rotated(Insulated_t,4)
Pistons=rotated(Piston,4)
Sticky_Pistons=rotated(Sticky_Piston,4)
Delayers=rotated(Delayer,4)

a.set_buttons(Normal_block,Mesecon,Switch,Inverters,Diodes,Ands,Nands,Xors,Insulateds,
              Insulated_ts,RedLightStone,Pistons,Piston_Up,Piston_Down,Sticky_Pistons,Sticky_Piston_Up,
              Sticky_Piston_Down,Sand,Delayers)
os.chdir(TOPDIR)
a.mainloop()