2d_anim.py

#2d_anim.py
#Maurits van Riezen (mousetail)
#23 November 2015
#Requires python 3 and pygame for python 3

import pygame
import random
import itertools
import os

class Item(object):
    def __init__(self, position):
        self.color=random.choice(((0, 0, 0),(255,255,255)))
        self.borderColor=tuple(255-i for i in self.color)
        
        self.circle=random.choice((True,False))
        self.position=list(position) #Position is used for external reference only, it is not ever used

    def draw(self, surface, position):
        if self.circle:
            pygame.draw.circle(surface, self.color, position, 8, 0)
            pygame.draw.circle(surface, self.borderColor, position, 8, 2)
            
        else:
            pygame.draw.rect(surface, self.color, (position[0]-8,position[1]-8,16,16))
            pygame.draw.rect(surface, self.borderColor, (position[0]-8,position[1]-8,16,16), 2)
class Game(object):

    WIDTH=8
    HEIGHT=6
    SPEED=180
    
    def __init__(self):
        self.screen=pygame.display.set_mode((128*self.WIDTH, self.HEIGHT*128))

        self.generate()

        self.drawGUI=True
        self.holeIndex=0

        self.recording=False
        self.draw()
        self.check()
        
        for iteration in range(4):

            for i in range(len(self.machines)):
                for j in range(len(self.machines[i])):
                    if random.randint(0,2)==1:
                        done=False
                        for x in range(-1,2):
                            for y in range(-1, 2):
                                if ((x==0) ^ (y==0)) and self.machines[i][j].__class__.getInputSides(x,y):
                                    self.machines[i][j].addItem(Item((0,64)),(x, y))
                                    done=True
                                    break
                            if done:
                                break
            
            for i in range(random.randint(12,48)):
                self.update()

    def generate(self):
        mainClasses=[]
        midClasses=[]
        junkClasses=[]

        self.whiteHoles=[]

        mainClasses.append(splitterMerger(((-1,0),(1,0)),((0,-1),(0,1))))
        mainClasses.append(splitterMerger(((0,-1),(0,1)),((-1,0),(1,0))))
        
        x=0
        y=1
        for direct in range(4):
            directions=((x,y),(y,-x),(-x,-y),(-y,x))
            gr=(random.choice((mainClasses,midClasses,midClasses,midClasses)) for i in range(3))
            next(gr).append(bend(directions[0],directions[1]))
            next(gr).append(bend(directions[1], directions[0]))
            next(gr).append(bend(directions[0], directions[2]))
            for i in range(-1,2):
                for j in range(-1,2):
                    for k in range(-1,2):
                        if (j>i and k>i and k>=j):
                            if (j!=k):
                                l=merger((directions[i],directions[j],directions[k]),
                                         directions[2])
                                l2=splitter((directions[i],directions[j],directions[k]),
                                            directions[2])
                                
                            else:
                                l=merger((directions[i],directions[k]),directions[2])
                                l2=splitter((directions[i],directions[k]),directions[2])
                            if j==k and random.randint(0,10)==1:
                                mainClasses.append(l2)
                                mainClasses.append(l)
                            else:
                                midClasses.append(l2)
                                midClasses.append(l)


            midClasses.append(crosser(directions[0],directions[1],directions[3],directions[2]))
            if direct==1 or direct==2:
                midClasses.append(crosser(directions[0],directions[1],directions[2],
                                          directions[3]))
            
            x, y=directions[1]

        for i in range(2):
            for j in range(2):
                for k in range(2):
                    for l in range(2):
                        dirs=(0,1),(1,0),(-1,0),(0,-1)
                        if (i or j or k or l):
                            junkClasses.append(whiteHole(tuple(dirs[m] for m in range(4) if (i,j,k,l)[m])))
                        junkClasses.append(blackHole(tuple(dirs[m] for m in range(4) if (i,j,k,l)[m])))
        
        self.machines=[]
        for i in range(self.WIDTH):
            self.machines.append([None,]*self.HEIGHT)
        
        for i in range(30):
            x=random.randint(0,len(self.machines)-1)
            y=random.randint(0,len(self.machines[x])-1)
            if self.machines[x][y] is None:
                self.machines[x][y]=self.findMachine(x,y,mainClasses,30)
        
        for x in range(len(self.machines)):
            for y in range(len(self.machines[0])):
                if (self.machines[x][y] is None):
                    self.machines[x][y]=self.findMachine(x,y,mainClasses,30)
                    #if self.machines[x][y]!=None: print ("first try",(x,y))
                if (self.machines[x][y] is None):
                    self.machines[x][y]=self.findMachine(x,y,midClasses,480)
                    #if self.machines[x][y]!=None: print ("second try",(x,y))
                if (self.machines[x][y] is None):
                    self.machines[x][y]=self.findMachine(x,y,mainClasses,400)
                    #if self.machines[x][y]!=None: print ("third try",(x,y))
                if self.machines[x][y] is None:
                    self.machines[x][y]=self.findMachine(x,y,junkClasses,660)
                    #if self.machines[x][y]!=None: print ("fourth try",(x,y))
                if self.machines[x][y] is None:
                    #print ("giving up",(x,y))
                    self.machines[x][y]=junkClasses[-1]()
                if self.machines[x][y].getInputSides(0,0):
                    self.whiteHoles.append(self.machines[x][y])
                #print (x,y,self.machines[x][y])

    def findMachine(self, x, y, group, numiterations=60):
        dirs=(0,1),(1,0),(0,-1),(-1,0)
        for i in range(numiterations):
            machine=random.choice(group)
            done=True
            for k in range(4):
                oldMachine=self.getMachineAt((x,y),dirs[k])
                if oldMachine is None:
                    pass
                elif ((machine.getOutputSides(*dirs[k]) and not oldMachine.getInputSides(*dirs[k-2])) or
                     (machine.getInputSides(*dirs[k]) and not oldMachine.getOutputSides(*dirs[k-2])) or
                     (oldMachine.getOutputSides(*dirs[k-2]) and not machine.getInputSides(*dirs[k])) or
                     (oldMachine.getInputSides(*dirs[k-2]) and not machine.getOutputSides(*dirs[k]))):
                    done=False
                    done=False
            if done:
                for dx, dy in dirs:
                    if self.getMachineAt((x,y),(dx,dy)) is None:
                        pass
                    elif machine.getOutputSides(dx,dy):\
                        assert self.getMachineAt((x,y),(dx,dy)).getInputSides(-dx,-dy), str((x,y))+str((dx,dy))
                    elif machine.getInputSides(dx,dy):
                        assert self.getMachineAt((x,y),(dx,dy)).getOutputSides(-dx,-dy), str((x,y))+str((dx,dy))
                    elif not machine.getInputSides(dx, dy) and not machine.getInputSides(dx, dy):
                        assert (not self.getMachineAt((x,y),(dx,dy)).getOutputSides(-dx,-dy) and
                                not self.getMachineAt((x,y),(dx,dy)).getInputSides(-dx,-dy)), str((x,y))+str((dx,dy))
                #print ("took",i,"iterations ",(x,y))
                
                return machine()
        return None

    def check(self):
        dirs=(0,1),(1,0),(0,-1),(-1,0)
        for x, i in enumerate(self.machines):
            for y, j in enumerate(i):
                assert self.getMachineAt((x,y),(0,0))!=None, str(x,y)
                for dx, dy in dirs:
                    if self.getMachineAt((x,y),(0,0)).getOutputSides(dx,dy):
                        assert self.getMachineAt((x,y),(dx,dy)).getInputSides(-dx,-dy), str((x,y))+str((dx,dy))
                    if self.getMachineAt((x,y),(0,0)).getInputSides(dx,dy):
                        assert self.getMachineAt((x,y),(dx,dy)).getOutputSides(-dx,-dy), str((x,y))+str((dx,dy))
    def getMachineAt(self, pos, rel=(0,0)):
        return self.machines[(pos[0]+rel[0])%len(self.machines)][(pos[1]+rel[1])%len(self.machines[0])]
    
    def update(self):
        items=[]
        for x, column in enumerate(self.machines):
            for y, machine in enumerate(column):
                items.extend((x+dx,y+dy, (-dx, -dy), item) for ((dx, dy), item) in machine.update())
        for x, y, direction, item in items:
            if direction!=(0,0):
                self.getMachineAt((x,y),(0,0)).addItem(item, direction)
            else:
                self.holeIndex+=1
                if self.holeIndex>=len(self.whiteHoles):
                    self.holeIndex=0
                if len(self.whiteHoles)>0:
                    self.whiteHoles[self.holeIndex].addItem(item, direction)

    def draw(self):
        self.screen.fill((0,0,0))
        if self.drawGUI:
            for x, i in enumerate(self.machines):
                for y, j in enumerate(i):
                    j.drawBack(self.screen, (128*x, 128*y))
        for x, i in enumerate(self.machines):
            for y, j in enumerate(i):
                j.draw(self.screen, (128*x, 128*y))
        pygame.display.flip()

    def event(self):
        for event in pygame.event.get():
            if event.type==pygame.QUIT:
                self.running=False
            elif event.type==pygame.KEYDOWN:
                if event.key==pygame.K_g:
                    self.drawGUI=not self.drawGUI
                elif event.key==pygame.K_r:
                    if self.recording:
                        self.stopRecording()
                    else:
                        self.startRecording()
                #print ("QUIT")

    def run(self):
        clock=pygame.time.Clock()
        self.running=True
        while self.running:
            clock.tick(self.SPEED)
            self.update()
            self.draw()
            if self.recording:
                self.record()
            self.event()
    def startRecording(self):
        index=0
        while os.path.exists(str(index)):
            index+=1
        os.mkdir(str(index))
        self.recorddir=str(index)
        self.recording=True
        self.framenumber=0
    def record(self):
        if framenumber%2==0:
            pygame.image.save(self.screen, self.recorddir+"/"+str(self.framenumber)+".png")
        self.framenumber+=1
    def stopRecording(self):
        self.recording=False

class Machine(object):
    @staticmethod
    def getInputSides(xoffset, yoffset):
        return False
    @staticmethod
    def getOutputSides(xoffset, yoffset):
        return False
######
#There are a total of 81 combinations:
#so far, I have
# 1 straigt (/4)     | 1-1
# 8 bends (out of 8) | 1-1
#16 mergers          | 3-1 2-1
#16 splitters        | 1-3 1-2
#I need:
# 6 crossings        | 2-2
#16 black holes      | 1-0 2-0 3-0 4-0
#16 white holes      | 0-1 0-2 0-3 0-4
class ConveyorBelt(Machine):

    @staticmethod
    def getInputSides(xoffset, yoffset):
        return yoffset==0 and xoffset==-1
    @staticmethod
    def getOutputSides(xoffset, yoffset):
        return yoffset==0 and xoffset==1

    def __init__(self):
        self.items=[]

    def update(self):
        out=[]
        for i in self.items:
            i.position[0]+=1
            if i.position[0]>128:
                out.append(i)
        
        return (self.items.remove(i) or ((1,0),i) for i in out)

    def addItem(self, item, direction):
        if direction==(-1,0):
            self.items.append(item)
            item.position[0]=0
            item.position[1]=64
        else:
            raise ValueError(direction)

    def draw(self, surface, position):
        for i in self.items:
            assert -64<=i.position[0]<=64 and -64<=i.position[1]<=64, "position is "+str(i.position)
            i.draw(surface, (position[0]+i.position[0], position[1]+i.position[1]))


def bend(inSide, outSide):
    class ActualBend(Machine):
        @staticmethod
        def getInputSides(xoffset, yoffset):
            return xoffset==inSide[0] and yoffset==inSide[1]
        @staticmethod
        def getOutputSides(xoffset, yoffset):
            return xoffset==outSide[0] and yoffset==outSide[1]

        def __init__(self):
            self.items=[]

        def update(self):
            out=[]
            for i in self.items:
                if ((inSide[0]!=0 and i.position[0]//inSide[0]>0) or
                   inSide[1]!=0 and i.position[1]//inSide[1]>0):
                    i.position[0]-=inSide[0]
                    i.position[1]-=inSide[1]
                else:
                    i.position[0]+=outSide[0]
                    i.position[1]+=outSide[1]
                if (outSide[0]!=0 and i.position[0]//outSide[0]==64) or (outSide[1]!=0 and i.position[1]//outSide[1]==64):
                    out.append(i)
            
            return (self.items.remove(i) or (outSide,i) for i in out)

        def addItem(self, item, direction):
            self.items.append(item)
            if inSide[0]!=0:
                item.position[0]=inSide[0]*64
                item.position[1]=0
            elif inSide[1]!=0:
                item.position[1]=inSide[1]*64
                item.position[0]=0
        def drawBack(self, surface, position):
            pygame.draw.lines(surface, (0,0,0), 0, ((position[0]+64+inSide[0]*64, position[1]+64+inSide[1]*64),
                                                    (position[0]+64, position[1]+64),
                                                    (position[0]+64+outSide[0]*64, position[1]+64+outSide[1]*64)),4)
            pygame.draw.lines(surface, (255,255,255), 0, ((position[0]+64+inSide[0]*64, position[1]+64+inSide[1]*64),
                                                    (position[0]+64, position[1]+64),
                                                    (position[0]+64+outSide[0]*64, position[1]+64+outSide[1]*64)))
        def draw(self, surface, position):
            for i in self.items:
                assert -64<=i.position[0]<=64 and -64<=i.position[1]<=64, "position is "+str(i.position)
                i.draw(surface, (position[0]+i.position[0]+64, position[1]+i.position[1]+64))
    return ActualBend

def merger(entrances, exit):
    class ActualMerger(Machine):
        @staticmethod
        def getInputSides(xoffset, yoffset):
            for entrance in entrances:
               if (xoffset==entrance[0] and yoffset==entrance[1]) :
                   return True
            return False
        @staticmethod
        def getOutputSides(xoffset, yoffset):
            return xoffset==exit[0] and yoffset==exit[1]

        def __init__(self):
            self.quiers=tuple((i,[]) for i in entrances)
            self.exitquier=[]
            self.quirpos=0
            
        def update(self):
            out=[]

            for item in self.exitquier:
                if (item.position[0]==0 and exit[0]==0):
                    item.position[1]+=exit[1]
                elif (item.position[1]==0 and exit[1]==0):
                    item.position[0]+=exit[0]
                elif (item.position[0]<0 and exit[0]==0):
                    item.position[0]+=1
                elif (item.position[0]>0 and exit[0]==0):
                    item.position[0]-=1
                elif (item.position[1]<0 and exit[1]==0):
                    item.position[1]+=1
                elif (item.position[1]>0 and exit[1]==0):
                    item.position[1]-=1

                if abs(item.position[0])==64 or abs(item.position[1])==64:
                    out.append(item)

                assert abs(item.position[0]<=64) and abs(item.position[1])<=64, item.position

            if (len(self.exitquier)==0 or
                (exit[0]!=0 and abs(self.exitquier[-1].position[0])>=16) or
                (exit[1]!=0 and abs(self.exitquier[-1].position[1])>=16)):
                startf=self.quirpos
                self.quirpos+=1
                if self.quirpos>=len(self.quiers):
                    self.quirpos=0
                f=self.quiers[self.quirpos]
                while startf!=self.quirpos and (len(f[1])==0 or abs(f[1][0].position[0])>16 or abs(f[1][0].position[1])>16):
                    self.quirpos+=1
                    if self.quirpos>=len(self.quiers):
                        self.quirpos=0
                    f=self.quiers[self.quirpos]
                if len(f[1])!=0:
                    item=f[1][0]
                    if (abs(item.position[0])<=16 and abs(item.position[1])<=16):
                        self.exitquier.append(f[1].pop(0))

            for key, value in self.quiers:
                for index, item in enumerate(value):
                    if ((index!=0 and (abs(item.position[0]-value[index-1].position[0]+item.position[1]-value[index-1].position[1])>16)) or
                        (index==0)) and (abs(item.position[0])>=16 or abs(item.position[1])>=16):
                        item.position[0]-=key[0]
                        item.position[1]-=key[1]
                        assert abs(item.position[0]<=64) and abs(item.position[1])<=64, item.position
            return (self.exitquier.remove(i) or (exit, i) for i in out)
        def addItem(self, item, direction):
            self.quiers[entrances.index(tuple(direction))][1].append(item)
            item.position[0]=direction[0]*64
            item.position[1]=direction[1]*64
            assert abs(item.position[0]<=64) and abs(item.position[1])<=64
                
        def drawBack(self, surface, position):
            pygame.draw.line(surface, (100,0,0), (position[0]+64, position[1]+64),
                             (position[0]+64+64*exit[0], position[1]+64+64*exit[1]),3)
            for i in entrances:
                pygame.draw.line(surface, (100,0,0), (position[0]+64, position[1]+64),
                             (position[0]+64+64*i[0], position[1]+64+64*i[1]))
        def draw(self, surface, position):
            for i in itertools.chain(self.exitquier, *(item for key, item in self.quiers)):
                assert -64<=i.position[0]<=64 and -64<=i.position[1]<=64, "position is "+str(i.position)
                i.draw(surface, (position[0]+i.position[0]+64, position[1]+i.position[1]+64))
    return ActualMerger

def splitter(exits, entrance):
    assert (entrance[0]==0) ^ (entrance[1]==0)
    
    class ActualSplitter(Machine):
        
        @staticmethod
        def getOutputSides(xoffset, yoffset):
            for exit in exits:
               if (xoffset==exit[0] and yoffset==exit[1]) :
                   return True
            return False
        
        @staticmethod
        def getInputSides(xoffset, yoffset):
            return xoffset==entrance[0] and yoffset==entrance[1]

        def __init__(self):
            self.quiers=[(i,[]) for i in exits]
            self.entrancequier=[]
            self.currentQuirePos=0
            
        def update(self):
            out=[]
            toremove=[]
            for item in self.entrancequier:
                item.position[0]-=entrance[0]
                item.position[1]-=entrance[1]
                assert -64<=item.position[0]<=64 and -64<=item.position[1]<=64, "position is "+str(item.position)

                if item.position[0]==0 and item.position[1]==0:
                    self.quiers[self.currentQuirePos][1].append(item)
                    toremove.append(item)
                    self.currentQuirePos+=1
                    if self.currentQuirePos>=len(self.quiers):
                        self.currentQuirePos=0
            for i in toremove:
                self.entrancequier.remove(i)

            for key, value in self.quiers:
                for index, item in enumerate(value):
                    item.position[0]+=key[0]
                    item.position[1]+=key[1]
                    assert -64<=item.position[0]<=64 and -64<=item.position[1]<=64, "position is "+str(item.position)+" key is "+str(key)
                    if abs(item.position[0])==64 or abs(item.position[1])==64:
                        out.append((key, item))
            for key, value in out:
                suc=False
                for i in self.quiers:
                    if i[0]==key:
                        i[1].remove(value)
                        suc=True
                        break
                if not suc:
                    print ("Can't find quire to remove "+str(value)+" from")
            return out
        def addItem(self, item, direction):
            assert direction[0]==entrance[0] and direction[1]==entrance[1], "direction="+str(direction)+"output="+str(entrance)
            self.entrancequier.append(item)
            item.position[0]=entrance[0]*64
            item.position[1]=entrance[1]*64
        def drawBack(self, surface, position):
            pygame.draw.line(surface, (255,0,0), (position[0]+64, position[1]+64),
                             (position[0]+64+64*entrance[0], position[1]+64+64*entrance[1]),3)
            for i in exits:
                pygame.draw.line(surface, (255,0,0), (position[0]+64, position[1]+64),
                             (position[0]+64+64*i[0], position[1]+64+64*i[1]))
        def draw(self, surface, position):
            for i in itertools.chain(self.entrancequier, *(i[1] for i in self.quiers)):
                assert -64<=i.position[0]<=64 and -64<=i.position[1]<=64, "position is "+str(i.position)
                i.draw(surface, (position[0]+i.position[0]+64, position[1]+i.position[1]+64))
    return ActualSplitter

def splitterMerger(ins, outs):
    class ActualSplitterMerger(Machine):
        def __init__(self):
            self.input=[[],[]]
            self.output=[[],[]]
            self.limbo=None
            self.limbodir=None
            self.inIndex=0
            self.outIndex=0

        @staticmethod
        def getOutputSides(xoffset, yoffset):
            for exit in outs:
               if (xoffset==exit[0] and yoffset==exit[1]) :
                   return True
            return False
        
        @staticmethod
        def getInputSides(xoffset, yoffset):
            for entrance in ins:
                if (xoffset==entrance[0] and yoffset==entrance[1]):
                    return True
            return False

        def update(self):
            out=[]
            for dir, lis in enumerate(self.output):
                toRemove=[]
                for itm in lis:
                    itm.position[0]+=outs[dir][0]
                    itm.position[1]+=outs[dir][1]
                    if abs(itm.position[0])==64 or abs(itm.position[1])==64:
                        out.append((outs[dir], itm))
                        toRemove.append(itm)
                for i in toRemove:
                    lis.remove(i)
            if self.limbo is None:
                start=self.inIndex
                self.incrementInIndex()
                while (self.inIndex!=start and (len(self.input[self.inIndex])==0 or
                    (abs(self.input[self.inIndex][0].position[0])!=16
                     and abs(self.input[self.inIndex][0].position[1])!=16))):
                    self.incrementInIndex()
                if (len(self.input[self.inIndex])>0 and
                       ((abs(self.input[self.inIndex][0].position[0])==16 or
                         abs(self.input[self.inIndex][0].position[1])==16))):
                    self.limbo=self.input[self.inIndex][0]
                    self.input[self.inIndex].pop(0)
                    self.incrementOutIndex()
                    self.limbodir=tuple(outs[self.outIndex][i]-ins[self.inIndex][i] for i in (0,1))
            if self.limbo is not None:
                self.limbo.position[0]+=self.limbodir[0]
                self.limbo.position[1]+=self.limbodir[1]
                if ((abs(self.limbo.position[0])==16 or abs(self.limbo.position[1])==16)):
                    self.output[self.outIndex].append(self.limbo)
                    self.limbo=None

            for dir, lst in enumerate(self.input):
                for index, itm in enumerate(lst):
                    if (index==0 or abs(lst[index-1].position[0]-itm.position[0])>16
                        or abs(lst[index-1].position[1]-itm.position[1])>16) and (
                        abs(itm.position[0])>16 or abs(itm.position[1])>16):
                        itm.position[0]-=ins[dir][0]
                        itm.position[1]-=ins[dir][1]
                        
            return out       
        def incrementInIndex(self):
            self.inIndex+=1
            if self.inIndex>=len(ins):
                self.inIndex=0
        def incrementOutIndex(self):
            self.outIndex+=1
            if self.outIndex>=len(outs):
                self.outIndex=0

        def addItem(self, itm, direction):
            self.input[ins.index(direction)].append(itm)
            itm.position[0]=64*direction[0]
            itm.position[1]=64*direction[1]

        def drawBack(self, surface, position):
            for x, y in ins:
                pygame.draw.line(surface, (0, 225, 0), (x*64+64+position[0],y*64+64+position[1]),(position[0]+64,position[1]+64))
            for x, y in outs:
                pygame.draw.line(surface, (0, 0, 225), (x*64+64+position[0],y*64+64+position[1]),(position[0]+64,position[1]+64))
        def draw(self, surface, position):
            for i in itertools.chain((self.limbo,), *itertools.chain(self.input,self.output)):
                if i:
                    assert -64<=i.position[0]<=64 and -64<=i.position[1]<=64, "position is "+str(i.position)
                    i.draw(surface, (position[0]+i.position[0]+64, position[1]+i.position[1]+64))
    return ActualSplitterMerger

def crosser(inOne, outOne, inTwo, outTwo):

    class ActualCrosser(Machine):
        @staticmethod
        def getOutputSides(xoffset, yoffset):
            return (xoffset==outOne[0] and yoffset==outOne[1]) or (xoffset==outTwo[0] and yoffset==outTwo[1])
        @staticmethod
        def getInputSides(xoffset, yoffset):
            return (xoffset==inOne[0] and yoffset==inOne[1]) or (xoffset==inTwo[0] and yoffset==inTwo[1])

        def __init__(self):
            self.trackOneStart=[]
            self.trackOneMid=[]
            self.trackOneEnd=[]
            self.trackTwoStart=[]
            self.trackTwoMid=[]
            self.trackTwoEnd=[]

        def update(self):
            toRemove=[]
            out=[]
            for inp, outp, start, mid, end in ((inOne, outOne, self.trackOneStart, self.trackOneMid, self.trackOneEnd),
                                               (inTwo, outTwo, self.trackTwoStart, self.trackTwoMid, self.trackTwoEnd)):
                toRemove.clear()
                for item in start:
                    item.position[0]-=inp[0]
                    item.position[1]-=inp[1]
                    if abs(item.position[0])==32 or abs(item.position[1])==32:
                        toRemove.append(item)
                        mid.append(item)
                for itm in toRemove:
                    start.remove(itm)
                toRemove.clear()
                for item in mid:
                    item.position[0]+=outp[0]-inp[0]
                    item.position[1]+=outp[1]-inp[1]
                    if abs(item.position[0])==32 or abs(item.position[1])==32:
                        toRemove.append(item)
                        end.append(item)

                for item in toRemove:
                    mid.remove(item)
                toRemove.clear()

                for item in end:
                    item.position[0]+=outp[0]
                    item.position[1]+=outp[1]
                    if abs(item.position[0])==64 or abs(item.position[1])==64:
                        toRemove.append(item)
                        out.append((outp,item))

                for item in toRemove:
                    end.remove(item)
            return out
        def addItem(self, item, direction):
            if (direction==inOne):
                item.position[0]=inOne[0]*64
                item.position[1]=inOne[1]*64
                self.trackOneStart.append(item)
            elif (direction==inTwo):
                item.position[0]=inTwo[0]*64
                item.position[1]=inTwo[1]*64
                self.trackTwoStart.append(item)
            else:
                raise ValueError(direction)
        def drawBack(self, surface, position):
            for ((x1, y1), (x2,y2)) in ((inOne, outOne), (inTwo, outTwo)):
                pygame.draw.lines(surface, (0,100,0), 0,
                                  ((position[0]+64+x1*64, position[1]+64+y1*64),
                                   (position[0]+64+x1*32, position[1]+64+y1*32),
                                   (position[0]+64+x2*32, position[1]+64+y2*32),
                                   (position[0]+64+x2*64, position[1]+64+y2*64))
                                  )
            
        def draw(self, surface, position):
            for item in itertools.chain(self.trackOneStart, self.trackOneMid, self.trackOneEnd, self.trackTwoStart, self.trackTwoMid, self.trackTwoEnd):
                assert -64<=item.position[0]<=64 and -64<=item.position[1]<=64, "position is "+str(item.position)
                item.draw(surface, (position[0]+64+item.position[0], position[1]+64+item.position[1]))
    return ActualCrosser

def blackHole(entrances):
    class ActualBlackHole(Machine):
        @staticmethod
        def getOutputSides(xoffset, yoffset):
            return xoffset==(0,0) and yoffset==(0,0)
        @staticmethod
        def getInputSides(xoffset, yoffset):
            return (xoffset, yoffset) in entrances
        def __init__(self):
            self.items=[]
        def update(self):
            l=tuple(((0,0), i) for i in self.items)
            self.items.clear()
            return l

        def addItem(self, item, direction):
            self.items.append(item)

        def draw(self, surface, position):
            pass
        
        def drawBack(self, surface, position):
            pygame.draw.circle(surface, (0,0,0), (position[0]+64,position[1]+64), 64)
            pygame.draw.circle(surface, (255,255,255), (position[0]+64,position[1]+64), 64,2)
    return ActualBlackHole
def whiteHole(entrances):
    class ActualWhiteHole(Machine):
        @staticmethod
        def getOutputSides(xoffset, yoffset):
            return (xoffset, yoffset) in entrances
        @staticmethod
        def getInputSides(xoffset, yoffset):
            return xoffset==0 and yoffset==0

        def __init__(self):
            self.items=[]
            self.exitIndex=0

        def update(self):
            itemscopy=self.items
            self.items=[]
            out=[]
            for i in itemscopy:
                self.exitIndex+=1
                if self.exitIndex>=len(entrances):
                    self.exitIndex=0
                out.append((entrances[self.exitIndex],i))
            return out
        def addItem(self, item, direction):
            self.items.append(item)

        def drawBack(self, surface, position):
            pygame.draw.circle(surface, (255,255,255), (position[0]+64,position[1]+64), 62, 0)
        
        def draw(self, surface, position):
            pass
        
    return ActualWhiteHole

                
if __name__=="__main__":
    Game().run()
    pygame.quit()