initial commit

01_clock/v01/clock.py

@@ -0,0 +1,99 @@
+import pygame
+import sys
+import math
+import datetime
+
+#Attribute der Uhr:---------------------------------------------------------------------------------
+windowMargin = 30			#Abstand Uhr -> Fensterwand
+windowWidth = 600
+windowHeight = windowWidth
+windowCenter = windowWidth/2, windowHeight/2
+clockMarginWidth = 20
+secondColor = (255,0,0)
+minuteColor = (100,200,0)
+hourColor = (100,200,0)
+clockMarginColor = (130,130,0)
+clockBackgroundColor = (20,40,30)
+backgroundColor = (255,255,255)
+hourCursorLength = windowWidth/2.0 - windowMargin -140
+minuteCursorLength = windowWidth/2.0 - windowMargin - 40
+secondCursorLength = windowWidth/2.0 - windowMargin - 10
+
+virtualSpeed = 1
+useVirtualTimer = False
+
+pygame.init()
+screen = pygame.display.set_mode((windowWidth, windowHeight), pygame.HWSURFACE | pygame.DOUBLEBUF)
+pygame.display.set_caption('AnalogClock')
+#Grundlegende Funktionen:---------------------------------------------------------------------------
+
+#Funktion um die Position eines Zeiger zu ermitteln (0 Grad liegen auf 12 uhr!!!)
+def getCursorPositionDegrees(position, scale):
+	#offset von -90 grad um 0 grad bei 12 uhr zu haben:
+	cursorOffset = -90
+	degrees = 360.0 / scale * position + cursorOffset
+	return degrees
+
+#zur Umrechnung in Bogenmass:
+def gradToBogenmass(degrees):
+	return degrees/180.0*math.pi
+
+#endpunkte der Zeiger berechnen:
+def getCirclePoint(position, scale, cursorLength):
+	degrees = getCursorPositionDegrees(position, scale)
+	bogenmass = gradToBogenmass(degrees)
+	xPos = round(math.cos(bogenmass)*cursorLength+windowCenter[0])
+	yPos = round(math.sin(bogenmass)*cursorLength+windowCenter[1])
+	return (xPos,yPos)
+#Grafikfunktionen:----------------------------------------------------------------------------------
+def drawBackground():
+	screen.fill(backgroundColor)
+	pygame.draw.ellipse(screen, clockMarginColor, (windowMargin, windowMargin, windowWidth-2*windowMargin, windowWidth-2*windowMargin))
+	pygame.draw.ellipse(screen, clockBackgroundColor,(windowMargin+clockMarginWidth/2,
+		windowMargin+clockMarginWidth/2, windowWidth-(windowMargin+clockMarginWidth/2)*2,
+		windowWidth-(windowMargin+clockMarginWidth/2)*2))
+
+def drawForeground():
+	pygame.draw.ellipse(screen,clockMarginColor,(windowWidth/2.0-9, windowHeight/2.0-9, 18, 18))
+
+def drawCursor(color, width, length, position, scale):
+	end = getCirclePoint(position, scale, length)
+	pygame.draw.line(screen, color, windowCenter, end, width)
+
+def drawCurrentTime():
+	if useVirtualTimer:
+		global hour, minute, second, micro
+		timeGoesOn()
+	else:
+		now = datetime.datetime.now()
+		micro = now.microsecond
+		hour = now.hour
+		minute = now.minute
+		second = now.second
+
+	drawCursor(hourColor,15,hourCursorLength,hour+minute/60.0, 12)
+	drawCursor(minuteColor, 8, minuteCursorLength, minute+second/60.0, 60)
+	drawCursor(secondColor, 3, secondCursorLength, second+micro/1000000.0,60)
+#Enventhandling:------------------------------------------------------------------------------------
+def handleEvents():
+	for event in pygame.event.get():
+		if event.type == pygame.QUIT:
+			sys.exit(0)
+		elif event.type == pygame.KEYDOWN:
+			sys.exit(0)
+#die Main:------------------------------------------------------------------------------------------
+def main():
+	#Hauptschleife:
+	while True:
+		handleEvents()
+		screen.fill(backgroundColor)
+
+		drawBackground()
+		drawCurrentTime()
+		drawForeground()
+
+		pygame.display.flip()
+		pygame.time.delay(10)
+
+if __name__ == '__main__':
+	main()

02_gameOfLife/Main.py

@@ -0,0 +1,147 @@
+#!/usr/bin/python
+import pygame
+import random
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from pygame.locals import *
+
+video_flags = OPENGL | HWSURFACE | DOUBLEBUF | FULLSCREEN
+
+pygame.init()
+
+dinfo = pygame.display.Info();
+
+livingSpaceWidth = 48
+livingSpaceHeight = 27
+
+creatureW = dinfo.current_w/(livingSpaceWidth)
+creatureH = dinfo.current_h/(livingSpaceHeight)
+
+FPS = 40
+
+livingSpace = []
+
+def resize((width, height)):
+    if height == 0:
+        height = 1
+    glViewport(0, 0, width, height)
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity()
+    glOrtho(0.0, livingSpaceWidth * creatureW, livingSpaceHeight * creatureH, 0.0, -6.0, 0.0)
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity()
+
+def init():
+    glClearColor(0.0, 0.0, 0.0, 0.0)
+
+def initLivingSpace():
+    for x in range(livingSpaceWidth):
+        livingSpace.append([])
+        for y in range(livingSpaceHeight):
+            if random.randint(0,1) ==1:
+                livingSpace[x].append(1000)
+            else:
+                livingSpace[x].append(0)
+
+def isAlive(x,y):
+    return livingSpace[x][y] == 1000
+
+def draw():
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    glLoadIdentity()
+    glTranslatef(0.0,0.0,3.0)
+
+
+    glBegin(GL_QUADS)
+    for column in range(livingSpaceWidth):
+        for row in range(livingSpaceHeight):
+            if livingSpace[column][row] != 0:
+                health = float(float(livingSpace[column][row])/1000.0)
+
+                glColor4f(health*(float(column)/float(livingSpaceWidth)),
+                    health*(float(livingSpaceWidth-column)/float(livingSpaceWidth)),
+                    health*(float(row)/float(livingSpaceHeight)),1.0)
+                x = column * creatureW
+                y = row * creatureH
+
+                glVertex3f(x,y,0.0)
+                glVertex3f(x + creatureW-1.0,y,0.0)
+                glVertex3f(x+creatureW-1,y+creatureH-1,0.0)
+                glVertex3f(x,y+creatureH-1,0.0)
+
+    glEnd()
+
+def getNeighborCount(x,y):
+    count = 0
+
+    xpn = (x + 1) % livingSpaceWidth
+    ypn = (y + 1) % livingSpaceHeight
+    # nach unten hin ist keine ausnahmebehandlung noetig,
+    # da python bei negativen indizes automatisch die liste von hinten
+    # durchlaeuft
+
+    # Vorsicht: boolscher Wert wird hier als Int genutzt!
+    count += isAlive(x,ypn)
+    count += isAlive(xpn,ypn)
+    count += isAlive(xpn,y)
+    count += isAlive(xpn,y-1)
+    count += isAlive(x,y-1)
+    count += isAlive(x-1,y-1)
+    count += isAlive(x-1,y)
+    count += isAlive(x-1,ypn)
+
+    return count
+
+def calculateNextGeneration():
+    neighborCount = []
+    for column in range(livingSpaceWidth):
+        neighborCount.append([])
+        for row in range(livingSpaceHeight):
+            neighborCount[column].append(getNeighborCount(column,row))
+
+    for column in range(livingSpaceWidth):
+        for row in range(livingSpaceHeight):
+            if 2 <= neighborCount[column][row] <= 3:
+                if neighborCount[column][row] == 3:
+                    livingSpace[column][row] = 1000
+                if not isAlive(column,row):
+                    livingSpace[column][row] = float(livingSpace[column][row])/1.2
+
+            else:
+                livingSpace[column][row] = float(livingSpace[column][row])/1.2
+
+            if livingSpace[column][row] < 20:
+                livingSpace[column][row] = 0
+
+def main():
+
+    pygame.display.set_mode((dinfo.current_w,dinfo.current_h),video_flags)
+
+    initLivingSpace()
+    resize((dinfo.current_w,dinfo.current_h))
+    init()
+
+    clock = pygame.time.Clock()
+
+    frames = 0
+
+    #Hauptschleife:
+    while True:
+
+
+        ticktime = clock.tick(FPS)
+        #print ticktime
+        event = pygame.event.poll()
+        if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
+            break
+
+
+        draw()
+
+        pygame.display.flip()
+        calculateNextGeneration()
+
+
+
+if __name__ == '__main__':
+    main()

README.md

@@ -0,0 +1 @@
+just some stupid old python projects i created years ago

arcadegame/ball.py

@@ -0,0 +1,45 @@
+import pygame
+from pygame.locals import *
+from sys import exit
+
+class ball(object):
+    def __init__(self, x,y,dx,dy):
+        self.x = x
+        self.y = y
+        self.dx = dx
+        self.dy = dy
+    
+    def setX(self,x):
+        self.x = x
+    
+    def setY(self,y):
+        self.y = y
+    
+    def setDx(self,dx):
+        self.dx = dx
+    
+    def setDy(self,dy):
+        self.dy=dy
+        
+    
+    def getX(self):
+        return self.x
+    
+    def getY(self):
+        return self.y
+    
+    def getDx(self):
+        return self.dx
+    
+    def getDy(self):
+        return self.dy
+        
+    
+    def update(self):
+        self.x +=self.dx
+        self.y +=self.dy
+        
+    def draw(self,screen):
+        pygame.draw.rect(screen,(255,255,255),Rect(self.x-5,self.y-5,10,10))
+    
+    

arcadegame/bat.py

@@ -0,0 +1,38 @@
+import pygame
+from pygame.locals import *
+from sys import exit
+
+class bat(object):
+    
+    def __init__(self, x,y,w,h,dy, maxY):
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+        self.dy = dy
+        self.maxY = maxY
+    
+    def moveUp(self):
+        self.y-= self.dy
+        if self.y<0:
+            self.y=0
+            
+    def moveDown(self):
+        self.y += self.dy
+        if self.y+self.h > self.maxY:
+            self.y = self.maxY - self.h
+    
+    def getY(self):
+        return self.y
+    
+    def checkCollision(self,x,y):
+        if x<self.x or x>self.x+self.w:
+            return False
+        
+        if y<self.y or y > self.y + self.h:
+            return False
+        return True
+    
+    def draw(self, screen):
+        pygame.draw.rect(screen,(255,255,255),Rect(self.x,self.y,self.w,self.h))
+    

arcadegame/eventhandler.py

@@ -0,0 +1,200 @@
+import pygame
+from pygame.locals import *
+from sys import exit
+
+if __name__ == '__main__':
+    pygame.init()
+
+
+#modul, welches Werkzeuge enthaelt, die zur eventbearbeitung dienen.
+KEY_INACTIVE = 0
+KEY_PRESSED = 1
+KEY_HOLD = 2
+KEY_RELEASED = 3
+
+class EventHandler(object):
+    def __init__(self):
+        self.eventlist = []
+        
+    
+    def update(self):
+        
+        
+        self.eventlist = pygame.event.get()
+        
+            
+    
+    def getEventList(self):
+        return self.eventlist
+
+
+class KeyHandler(object):
+    
+    def __init__(self):
+        self.keyDict = {}
+        
+    
+    def registerKey(self,keycode):
+        self.keyDict[keycode] = KEY_INACTIVE
+    
+    def getKeyState(self,keycode):
+        
+        code = self.keyDict[keycode]
+        
+        if code == KEY_PRESSED:
+            self.keyDict[keycode] = KEY_HOLD
+        elif code == KEY_RELEASED:
+            self.keyDict[keycode] = KEY_INACTIVE
+        return code
+    
+    def update(self, e_handler):
+        
+        eventlist = e_handler.getEventList()
+        
+        #TODO: hier ist noch optimierungsbedarf, was die Geschwindigkeit angeht...
+        for event in eventlist:
+            
+            #I love verschachtelte if's ;)
+            if event.type == KEYUP or event.type == KEYDOWN:
+                if self.keyDict.has_key(event.key):
+                    
+                    if self.keyDict[event.key] == KEY_INACTIVE:
+                        if event.type == KEYDOWN:
+                            self.keyDict[event.key] = KEY_PRESSED
+                    
+                    elif  self.keyDict[event.key] == KEY_HOLD:
+                        if event.type == KEYUP:
+                            self.keyDict[event.key] = KEY_RELEASED
+                            
+            
+        
+
+#klasse eig unnoetig, da pygame diese viel bequemer selber bereitstellt...
+class MouseHandler(object):
+    
+    def __init__(self):
+        self.mouseX = 0;
+        self.mouseY = 0;
+        self.LeftButton = KEY_INACTIVE
+        self.MiddleButton = KEY_INACTIVE
+        self.RightButton = KEY_INACTIVE
+        self.isMouseMoved = False
+    
+    def update(self, e_handler):
+        elist = e_handler.getEventList()
+        
+        
+        for event in elist:
+            if event.type == MOUSEMOTION:
+                self.mouseX, self.mouseY = event.pos
+                self.isMouseMoved = True
+            elif event.type == MOUSEBUTTONDOWN:
+                if event.button == 1:
+                    if self.LeftButton == KEY_INACTIVE:
+                        self.LeftButton = KEY_PRESSED
+                elif event.button == 2:
+                    if self.MiddleButton == KEY_INACTIVE:
+                        self.MiddleButton = KEY_PRESSED
+                elif event.button == 3:
+                    if self.RightButton == KEY_INACTIVE:
+                        self.RightButton = KEY_PRESSED
+            elif event.type == MOUSEBUTTONUP:
+                if event.button == 1:
+                    if self.LeftButton == KEY_HOLD:
+                        self.LeftButton = KEY_RELEASED
+                elif event.button == 2:
+                    if self.MiddleButton == KEY_HOLD:
+                        self.MiddleButton = KEY_RELEASED
+                elif event.button == 3:
+                    if self.RightButton == KEY_HOLD:
+                        self.RightButton = KEY_RELEASED
+    
+    def getLeftButtonState(self):
+        code = self.LeftButton
+        
+        if code == KEY_PRESSED:
+            self.LeftButton = KEY_HOLD
+        elif code == KEY_RELEASED:
+            self.LeftButton = KEY_INACTIVE
+        return code
+    
+    def getMiddleButtonState(self):
+        code = self.MiddleButton
+        
+        if code == KEY_PRESSED:
+            self.MiddleButton = KEY_HOLD
+        elif code == KEY_RELEASED:
+            self.MiddleButton = KEY_INACTIVE
+        return code
+    
+    def getRightButtonState(self):
+        code = self.RightButton
+        
+        if code == KEY_PRESSED:
+            self.RightButton = KEY_HOLD
+        elif code == KEY_RELEASED:
+            self.RightButton = KEY_INACTIVE
+        return code
+    
+    def mouseMoved(self):
+        if self.isMouseMoved:
+            self.isMouseMoved = False
+            return True
+        return False
+    
+    def getMouseX(self):
+        return self.mouseX
+    
+    def getMouseY(self):
+        return self.mouseY
+    
+    def getMousePos(self):
+        return (self.mouseX, self.mouseY)
+
+
+    
+
+if __name__ == '__main__':
+    
+    font = pygame.font.SysFont("arial", 16);
+    
+    elist = EventHandler()
+    test = KeyHandler()
+    mouse = MouseHandler()
+    
+    screen = pygame.display.set_mode(( 800, 600),0,32);
+
+    
+    test.registerKey(K_UP)
+    test.registerKey(K_DOWN)
+    
+    while True:
+        
+        screen.fill((255, 255, 255))
+        elist.update();
+        test.update(elist)
+        mouse.update(elist)
+        
+        code = test.getKeyState(K_UP)
+        code2 = test.getKeyState(K_DOWN)
+        moved = mouse.mouseMoved()
+        
+        button = mouse.getLeftButtonState()
+        
+        pos = mouse.getMousePos()
+        
+        
+        
+        if code == KEY_RELEASED:
+            exit();
+        
+        screen.blit( font.render('KeyUp: '+str(code), True, (0, 0, 0)), (0, 0) )
+        screen.blit( font.render('KeyDown: '+str(code2), True, (0, 0, 0)), (0, 20) )
+        screen.blit( font.render('Maus: '+str(moved), True, (0, 0, 0)), (0, 40) )
+        screen.blit( font.render('Maus: '+str(button), True, (0, 0, 0)), (0, 60) )
+        screen.blit( font.render('Maus: '+str(pos), True, (0, 0, 0)), (0, 80) )
+        pygame.display.update()
+
+
+
+        

arcadegame/main.py

@@ -0,0 +1,164 @@
+#!/usr/bin/python
+
+import pygame
+import math
+from pygame.locals import *
+from sys import exit
+from ball import *
+from bat import *
+from eventhandler import *
+import eventhandler
+pygame.init();
+
+#spielvariablen:
+
+PLAYER_SPEED = 8
+KI_SPEED = 12
+
+GAMESPEED = 1.0
+MAXSPEED = 3.0
+SPEEDFAKTOR = 1.2
+
+PADHEIGHT = 100.0
+
+FPS = 60
+
+#hole infos ueber die derzeitige displaykonfiguration
+dinfo = pygame.display.Info();
+
+#mache einen neuen Bildschirm in vollbild
+screen = pygame.display.set_mode(( dinfo.current_w, dinfo.current_h),FULLSCREEN | HWSURFACE,dinfo.bitsize);
+#screen = pygame.display.set_mode(( 800, 600),HWSURFACE,dinfo.bitsize);
+
+font = pygame.font.SysFont("arial", 30);
+
+
+myball = ball(1050,50,-5,5)
+
+batleft = bat(20,dinfo.current_h/2-PADHEIGHT/2, 30, PADHEIGHT, PLAYER_SPEED, dinfo.current_h)
+batright =  bat(dinfo.current_w-50,dinfo.current_h/2-PADHEIGHT/2, 30, PADHEIGHT, KI_SPEED, dinfo.current_h)
+
+e_handler=EventHandler()
+keys = KeyHandler()
+keys.registerKey(K_ESCAPE)
+keys.registerKey(K_UP)
+keys.registerKey(K_DOWN)
+
+clock = pygame.time.Clock()
+
+speed = GAMESPEED;
+
+pointleft = 0
+pointright = 0
+
+error_counter = 0
+
+ticktime = 0.0
+
+realFps = 0
+fpsCounter = 0
+
+lastFps = 0
+
+
+while True:
+    
+    #timer:
+    
+    ticktime = clock.tick(FPS)
+    
+    #zeichenoperationen:
+    if (ticktime<1000.0/FPS+10):
+        screen.fill((0,0,0))
+        myball.draw(screen)
+        batleft.draw(screen)
+        batright.draw(screen)
+        screen.blit( font.render(str(""+str(pointleft)+" : "+str(pointright)), True, (255, 255, 255)), (dinfo.current_w/2-30, 20) )
+        screen.blit( font.render(str(lastFps), True, (255, 255, 255)), (dinfo.current_w/2-30, 60) )
+
+        pygame.display.update()
+        
+        realFps +=1
+    
+    #logik:
+    
+    e_handler.update()
+    keys.update(e_handler)
+    fpsCounter +=1
+    
+    if fpsCounter >= FPS:
+        lastFps = realFps
+        fpsCounter = 0
+        realFps = 0
+    
+    #spieler:
+    if keys.getKeyState(K_UP) == KEY_HOLD:
+        batleft.moveUp()
+    if keys.getKeyState(K_DOWN) == KEY_HOLD:
+        batleft.moveDown()
+    
+    #computer:
+    if myball.getY() < batright.getY()+20:
+        batright.moveUp()
+    if myball.getY() > batright.getY()+PADHEIGHT-20:
+        batright.moveDown()
+    
+    #kollisionsabfragen:
+    
+    if batleft.checkCollision(myball.getX(), myball.getY()) and myball.getDx() <0:
+        x = myball.getX()
+        y = myball.getY()
+        
+        y2 = batleft.getY()
+        
+        dy = (float(y-y2)/PADHEIGHT*10.0)-5.0
+        dx = 7.5-math.fabs(dy)
+        
+        myball.setDx(dx*speed)
+        myball.setDy(dy*speed)
+        
+        speed *= SPEEDFAKTOR
+    
+    if batright.checkCollision(myball.getX(), myball.getY()) and myball.getDx()>0:
+        x = myball.getX()
+        y = myball.getY()
+        
+        y2 = batright.getY()
+        
+        dy = (float(y-y2)/PADHEIGHT*10.0)-5.0
+        dx = 7.5-math.fabs(dy)
+        
+        myball.setDx(-dx*speed)
+        myball.setDy(dy*speed)
+        
+        speed *= SPEEDFAKTOR
+    
+    if speed > MAXSPEED:
+        speed = MAXSPEED
+    
+    if myball.getY()-10<0 or myball.getY()+10>dinfo.current_h:
+        myball.setDy(-myball.getDy())
+    myball.update()
+    
+    
+    
+    if myball.getX() < 0:
+        pointright +=1
+        speed = GAMESPEED
+        myball.setX(dinfo.current_w/2)
+        myball.setY(dinfo.current_h/2)
+        myball.setDx(-6)
+        myball.setDy(0)
+        
+    if myball.getX() > dinfo.current_w:
+        pointleft +=1
+        speed = GAMESPEED
+        myball.setX(dinfo.current_w/2)
+        myball.setY(dinfo.current_h/2)
+        myball.setDx(6)
+        myball.setDy(0)
+    
+    if keys.getKeyState(K_ESCAPE) != KEY_INACTIVE:
+        exit()
+        
+

laby2/Kachel.py

@@ -0,0 +1,77 @@
+from PIL import Image
+from PIL import ImageDraw
+
+NORTH = 0
+EAST = 1
+SOUTH = 2
+WEST = 3
+
+
+class Kachel:
+
+    def __init__(self, pos, size):
+        self.dirs = [False, False, False, False]
+        self.visited = False
+        self.pos = pos
+        self.size = size
+        self.walkable = False
+
+    def isVisited(self):
+        return self.visited
+
+    def getPos(self):
+        return self.pos
+
+    def open(self, direction):
+        self.dirs[direction] = True
+
+    def isOpen(self, direction):
+        return self.dirs[direction]
+
+    def touch(self):
+        self.visited = True
+
+    def makeWalkable(self):
+        self.walkable = True
+
+    def isWalkable(self):
+        return self.walkable
+
+    def getNumberOfOpenWays(self):
+        n = 0
+        for i in self.dirs:
+            if i:
+                n += 1
+
+        return n
+
+    def getArrayOfClosedWays(self):
+        result = []
+        for i in range(4):
+            if not self.dirs[i]:
+                result.append(i)
+        return result
+
+    def draw(self, target, offset):
+
+        pos = [(self.pos[0] * self. size[0] + offset[0],
+            self.pos[1] * self.size[1] + offset[1]),
+            ((self.pos[0] + 1) * self.size[0] + offset[0],
+            self.pos[1] * self.size[1] + offset[1]),
+            ((self.pos[0] + 1) * self.size[0] + offset[0],
+            (self.pos[1] + 1) * self.size[1] + offset[1]),
+            (self.pos[0] * self.size[0] + offset[0],
+            (self.pos[1] + 1) * self.size[1] + offset[1])]
+
+        if (not self.dirs[NORTH]):
+            target.line((pos[0], pos[1]), (0, 0, 0))
+
+        if (not self.dirs[EAST]):
+            target.line((pos[1], pos[2]), (0, 0, 0))
+
+        if (not self.dirs[SOUTH]):
+            target.line((pos[2], pos[3]), (0, 0, 0))
+
+        if (not self.dirs[WEST]):
+            target.line((pos[3], pos[0]), (0, 0, 0))
+

laby2/Laby.py

@@ -0,0 +1,255 @@
+#!/usr/bin/python
+from Kachel import *
+from PIL import Image
+from PIL import ImageDraw
+import random
+import sys
+import math
+
+CHAR_WALL = "X"
+CHAR_START = "*"
+CHAR_END = "#"
+
+
+class Laby:
+
+    def __init__(self, size, arraySize, kachelSize, waySteps):
+        self.kachelArray = []
+        self.size = size
+        self.arraySize = arraySize
+        self.kachelSize = kachelSize
+        self.img = None
+        self.drawObject = None
+        self.createImage()
+        self.createArray()
+        self.visitedFields = 0
+
+        self.maxWaysteps = waySteps    # ein aenderung dieses wertes duerfte
+                                       # den schwierigkeitsgrad beeinflussen
+
+    def createImage(self):
+        self.img = Image.new("RGB", (self.size[0], self.size[1]),
+            (255, 255, 255))
+        self.drawObject = ImageDraw.ImageDraw(self.img)
+
+    def createArray(self):
+        for x in range(self.arraySize[0]):
+            tmp = []
+            for y in range(self.arraySize[1]):
+                tmp.append(Kachel((x, y), self.kachelSize))
+
+            self.kachelArray.append(tmp)
+
+    def makeAllWalkable(self):
+        for y in self.kachelArray:
+            for x in y:
+                x.makeWalkable()
+
+    
+
+    def draw(self):
+        for i in self.kachelArray:
+            for j in i:
+                j.draw(self.drawObject, self.kachelSize)
+    
+    def saveToTxt(self, filename):
+        fobj = open(filename, "w")
+        for j in range(self.arraySize[0]*2 + 1):
+            fobj.write(CHAR_WALL)
+        fobj.write("\n")
+        for i in range(self.arraySize[1]):
+            fobj.write(CHAR_WALL)
+            for j in range(self.arraySize[0]):
+                if (i == 0 and j == 0):
+                    fobj.write(CHAR_START)
+                elif(i == self.arraySize[1]-1 and j == self.arraySize[0]-1):
+                    fobj.write(CHAR_END)
+                else:
+                    fobj.write(" ")
+                
+                if self.kachelArray[j][i].isOpen(EAST):
+                    fobj.write(" ")
+                else:
+                    fobj.write(CHAR_WALL)
+                
+            fobj.write("\n" + CHAR_WALL)
+            for j in range(self.arraySize[0]):
+                if self.kachelArray[j][i].isOpen(SOUTH):
+                    fobj.write(" ")
+                else:
+                    fobj.write(CHAR_WALL)
+                
+                fobj.write(CHAR_WALL)
+            
+            fobj.write("\n")
+        
+        fobj.close();
+
+    def showOnScreen(self):
+
+        self.img.show()
+
+    def save(self, filename):
+        self.img.save(filename)
+
+    def openWay(self, pos, direction):
+        self.kachelArray[pos[0]][pos[1]].open(direction)
+
+        if direction == NORTH:
+            if pos[1] > 0:
+                self.kachelArray[pos[0]][pos[1] - 1].open(SOUTH)
+        elif direction == EAST:
+            if pos[0] < self.arraySize[0] - 1:
+                self.kachelArray[pos[0] + 1][pos[1]].open(WEST)
+        elif direction == SOUTH:
+            if pos[1] < self.arraySize[1] - 1:
+                self.kachelArray[pos[0]][pos[1] + 1].open(NORTH)
+        elif direction == WEST:
+            if pos[0] > 0:
+                self.kachelArray[pos[0] - 1][pos[1]].open(EAST)
+
+    def scanNeighbours(self, scanPos):
+        scanResult = [0, 0, 0, 0]  # 0 = nix, 1 = unbesucht, 2 = besucht
+        # NORTH:
+        if scanPos[1] > 0:
+            north = self.kachelArray[scanPos[0]][scanPos[1] - 1]
+            if north.isWalkable():
+                if north.isVisited():
+                    scanResult[NORTH] = 2
+                else:
+                    scanResult[NORTH] = 1
+        # SOUTH:
+        if scanPos[1] < self.arraySize[1] - 1:
+            south = self.kachelArray[scanPos[0]][scanPos[1] + 1]
+            if south.isWalkable():
+                if south.isVisited():
+                    scanResult[SOUTH] = 2
+                else:
+                    scanResult[SOUTH] = 1
+        # WEST:
+        if scanPos[0] > 0:
+            west = self.kachelArray[scanPos[0] - 1][scanPos[1]]
+            if west.isWalkable():
+                if west.isVisited():
+                    scanResult[WEST] = 2
+                else:
+                    scanResult[WEST] = 1
+        # EAST:
+        if scanPos[0] < self.arraySize[0] - 1:
+            east = self.kachelArray[scanPos[0] + 1][scanPos[1]]
+            if east.isWalkable():
+                if east.isVisited():
+                    scanResult[EAST] = 2
+                else:
+                    scanResult[EAST] = 1
+
+        return scanResult
+
+    def bakeWay(self, startPos):
+        self.pos = startPos
+        for c in range(self.maxWaysteps):   # pro weg maximal waysteps schritte
+
+            self.kachelArray[self.pos[0]][self.pos[1]].touch()
+            self.visitedFields += 1
+            neighbours = self.scanNeighbours(self.pos)
+            if neighbours.count(1) == 0:
+                break
+
+            possibleDirections = []
+            for i in range(4):
+                if neighbours[i] == 1:
+                    possibleDirections.append(i)
+
+            #zufaellige richtung waehlen:
+            nextDir = random.sample(possibleDirections, 1)[0]
+            self.openWay(self.pos, nextDir)
+
+            #zur naechsten Kachel gehen:
+            if nextDir == NORTH:
+                self.pos = (self.pos[0], self.pos[1] - 1)
+
+            elif nextDir == EAST:
+                self.pos = (self.pos[0] + 1, self.pos[1])
+
+            elif nextDir == SOUTH:
+                self.pos = (self.pos[0], self.pos[1] + 1)
+
+            elif nextDir == WEST:
+                self.pos = (self.pos[0] - 1, self.pos[1])
+
+    def bakeLaby(self, startPos, isFirstBake):
+        if isFirstBake:
+            print("Berechne Labyrinth...")
+            self.bakeWay(startPos)
+        unvisitedCounter = (self.arraySize[0]*self.arraySize[1]
+            - self.visitedFields)
+
+        while unvisitedCounter > 0:
+            #fortschritt in Prozent
+            print(str(float(self.visitedFields * 100.0)
+                / float(self.arraySize[0] * self.arraySize[1])) + "%")
+            # zaehle unbesuchte, an besuchten Feldern angrenzende Felder
+            neighbours = []
+            unvisitedCounter = 0
+            for y in self.kachelArray:
+                for x in y:
+                    if not x.isVisited():
+
+                        if self.scanNeighbours(x.getPos()).count(2) > 0:
+                            unvisitedCounter += 1
+                            neighbours.append(x)
+
+            if unvisitedCounter > 0:
+                nextPos = random.sample(neighbours, 1)[0]
+                tmp = self.scanNeighbours(nextPos.getPos())
+                possibleConnectDirs = []
+                for i in range(4):
+                    if tmp[i] == 2:
+                        possibleConnectDirs.append(i)
+
+                connectDir = random.sample(possibleConnectDirs, 1)[0]
+                self.openWay(nextPos.getPos(), connectDir)
+                self.bakeWay(nextPos.getPos())
+
+if __name__ == "__main__":
+
+    #programmaufruf: Laby.py [W] [H] [Feldgroesse] [filename]
+
+    try:
+        KACHELSIZE = int(sys.argv[3])
+        WIDTH = int(sys.argv[1])
+        HEIGHT = int(sys.argv[2])
+        FILENAME = sys.argv[4]
+
+    except:
+        print("\nFehlerhafte Parameter!")
+        print("Benoetigte Parameter:"
+            + "[BREITE] [HOEHE] [FELDGROESSE] [DATEINAME] <WAYSTEPS>"
+            + "\n\nBREITE: die Breite des Labyrinthes in Anzahl an Feldern"
+            + "\n\nHOEHE: die Hoehe des Labyrinthes in Anzahl an Feldern"
+            + "\n\nFELDGROESSE: Kantenlaenge eines Feldes in Pixeln"
+            + "\n\nDATEINAME: Dateiname fuer das fertige Labyrinth (ohne dateiendung)"
+            + "\n\nWAYSTEPS(optional): gibt die maximale Laenge eines "
+            + "\nWegstuecks in Feldern an, die ohne Abzweigung vom Algorithmus"
+            + "\ngeneriert werden kann. Pauschal kann man sagen: je kleiner "
+            + "\nder Wert, desto kuerzer ist der kuerzeste Weg zwischen zwei "
+            + "\nPunkten im Labyrinth. Standardwert ist 100 \n")
+
+        sys.exit(0)
+
+    # optionale Argumente:
+    try:
+        WAYSTEPS = int(sys.argv[5])
+    except:
+        WAYSTEPS = 100
+
+    laby = Laby(((WIDTH + 2) * KACHELSIZE, (HEIGHT + 2) * KACHELSIZE),
+        (WIDTH, HEIGHT), (KACHELSIZE, KACHELSIZE), WAYSTEPS)
+    laby.makeAllWalkable()
+    laby.bakeLaby((0, 0),True)
+    laby.saveToTxt(FILENAME + ".txt")
+    laby.openWay((0, 0), WEST)
+    laby.openWay((WIDTH - 1, HEIGHT - 1), EAST)
+    laby.draw()
+    laby.save(FILENAME + ".png")
+    laby.showOnScreen()

simongame/button.py

@@ -0,0 +1,43 @@
+import tools
+import eventmanager
+import maus
+
+BUTTON_ALPHA_INACTIVE = 0.3
+BUTTON_ALPHA_SELECT = 0.8
+BUTTON_ALPHA_CLICKED = 1.0
+
+class button(object):
+
+    def __init__(self, mouse, posRect, color, text, font):
+        self.posRect = posRect
+        self.color = color
+
+        self.alpha = BUTTON_ALPHA_INACTIVE
+
+        self.text = text
+        self.font = font
+
+        self.mouse = mouse
+
+        self.clicked = False
+
+    def isClicked(self):
+
+        return self.mouse.getState(0) == maus.BUTTON_RELEASED and tools.is2DPointCollision(self.mouse.getPos(),self.posRect)
+
+    def update(self):
+        if tools.is2DPointCollision(self.mouse.getPos(),self.posRect):
+            if self.mouse.getState(0) == maus.BUTTON_HOLD:
+                self.alpha = BUTTON_ALPHA_CLICKED
+            else:
+                self.alpha = BUTTON_ALPHA_SELECT
+        else:
+            self.alpha = BUTTON_ALPHA_INACTIVE
+
+    def draw(self):
+        tools.drawRect((self.posRect[0]-2,self.posRect[1]-2,self.posRect[2]+4,self.posRect[3]+4),0,(0.0,0.0,0.0,1.0))
+        tools.drawRect(self.posRect,0,(self.color[0],self.color[1],self.color[2],self.alpha))
+        tools.writePerFTGL(self.text,self.font,
+            (self.posRect[0] + 20,self.posRect[1]+self.posRect[3]/2+8),(1.0,1.0,1.0,1.0))
+
+

simongame/eventmanager.py

@@ -0,0 +1,21 @@
+import pygame
+from pygame.locals import *
+
+class eventmanager(object):
+    def __init__(self):
+        self.eventlist = []
+
+    def update(self):
+        self.eventlist = pygame.event.get()
+
+    def getAll(self):
+        return self.eventlist
+
+    def getByType(self,Type):
+        list = []
+        for event in self.eventlist:
+            if event.type == Type:
+                list.append(event)
+
+        return list
+

simongame/gitter.py

@@ -0,0 +1,227 @@
+import pygame
+import random
+from pygame.locals import *
+import tools
+import kachel
+from maus import *
+import eventmanager
+import FTGL
+import button
+
+#Groesse des Spielfeldes
+GITTER_W = 7
+GITTER_H = 5
+
+#GitterModi:
+MODE_RANDOM = 0
+MODE_SHOW = 1
+MODE_PLAY = 2
+
+#Werte fuer den Random Mode:
+
+RANDOM_FRAMES = 60      #Anzahl der Frames fuer eine einzelne Sequenz
+RANDOM_ELEMENT_RANGE =GITTER_W*GITTER_H/4 #Wie viele Elemente werden Maximal zufaellig aktiviert (muss kleinergleich sein als Gitter_W*Gitter_H)
+
+#Werte fuer den Show Mode:
+
+TIME_FACTOR = 0.9
+MIN_STEPTIME = 20
+
+COOLDOWNTIME = 20
+
+
+class gitter(object):
+    def __init__(self,size,eManager,mouse,sounds):
+        self.kachelarray = []
+
+        self.size = size
+
+        self.eManager = eManager
+        
+        self.kachelW = size[0]/GITTER_W
+        self.kachelH = size[1]/GITTER_H
+
+        self.sounds = sounds
+
+        self.mode = MODE_RANDOM
+
+        #Variablen fuer den MODE_RANDOM
+        self.randomFrame = 0
+        self.randomSequence = [] #wird auch fuer alle anderen Sequenzen verwendet
+
+        self.mausimaus = mouse
+      
+        for x in range(GITTER_W*GITTER_H):
+            self.kachelarray.append( kachel.kachel(x%GITTER_W,x//GITTER_W,self.kachelW,self.kachelH))
+
+        self.initRandomSequence()
+
+        #Variablen fuer den Play Mode:
+        self.level = 1
+        self.mistake = False
+        self.playingStep = 0
+        self.done = False
+
+        #Variablen fuer den Show Mode:        
+        self.curFrame = 0
+        self.maxFrame = MIN_STEPTIME
+
+        self.showing = False
+
+        self.cooldown = COOLDOWNTIME
+
+
+
+    
+    def getIndex(self,pos):
+        return pos[1]*GITTER_W + pos[0]
+    
+    def getPos(self,index):
+        return (index%GITTER_W,index//GITTER_W)
+
+    def deactivateAll(self):
+        for kachel in self.kachelarray:
+            kachel.deactivate()
+
+    def activateAll(self):
+        for kachel in self.kachelarray:
+            kachel.activate()
+
+    def setLevel(self,level):
+        self.level = level
+
+    def initRandomSequence(self):
+        self.randomFrame = 0
+
+        #alle deaktivieren:
+        self.deactivateAll()
+
+        #erzeuge eine sequenz aus kachelindizies, die 1 bis RANDOM_ELEMENT_RANGE lang ist
+        self.randomSequence = random.sample(range(GITTER_W*GITTER_H),random.randint(1,RANDOM_ELEMENT_RANGE))
+
+        #die in der random sequenz aktivieren:
+        for i in self.randomSequence:
+            self.kachelarray[i].activate()
+
+    def generatePlaySequence(self,level):
+        self.randomSequence = random.sample(range(GITTER_W*GITTER_H),level)
+
+    def changeMode(self,mode):
+        self.mode = mode
+
+        if mode == MODE_RANDOM:
+            self.randomFrame = 0
+
+            #noch kurz die richtige Loesung zeigen:
+            self.deactivateAll()
+            for i in self.randomSequence:
+                self.kachelarray[i].activate()
+
+        elif mode == MODE_SHOW:
+            self.done = False
+            self.cooldown = COOLDOWNTIME
+            self.showing = True
+            self.generatePlaySequence(self.level) #level sollte also vorher gesetzt werden !!!
+            self.curFrame = 0
+            self.maxFrame = MIN_STEPTIME + (TIME_FACTOR*MIN_STEPTIME)*self.level
+            self.activateAll()
+            self.sounds[1].play()
+
+
+        elif mode == MODE_PLAY:
+            self.cooldown = COOLDOWNTIME
+            self.mistake = False
+            self.playingStep = 0
+            self.activateAll()
+            self.sounds[1].play()
+
+
+        else:
+            pass #TODO: System fuer einheitliche Fehlermeldungen implementieren
+        
+    def getMode(self):
+        return self.mode
+
+    def readyToPlay(self):
+        return not self.showing
+
+    def readyToShow(self):
+        return self.done
+
+    def madeMistake(self):
+        return self.mistake
+
+    def inSequence(self,kachel):
+        
+        for i in range(self.level):
+            if self.getIndex(kachel.getPos()) == self.randomSequence[i]:
+                return True
+        return False
+
+
+    
+    def update(self):
+
+        if self.cooldown > 0:
+            self.cooldown -= 1
+            if self.cooldown == 0:
+                self.deactivateAll()
+
+            #und die kachel updaten:
+            for kachel in self.kachelarray:
+                kachel.update()
+        else:
+                
+            for kachel in self.kachelarray:
+                kachel.deselect()
+                kPos = kachel.getPos()
+                
+                mausPos = self.mausimaus.getPos()
+
+                mousePressed = self.mausimaus.getState(0) == BUTTON_PRESSED
+
+                #WARNUNG: nicht in den verschachtelungen verirren!!!
+                if not self.mode == MODE_SHOW:
+                    if tools.is2DPointCollision(mausPos,(kPos[0]*kPos[2],kPos[1]*kPos[3],kPos[2],kPos[3])):
+                        if not kachel.isActive:
+                            if mousePressed:
+
+                                kachel.activate()
+
+                                if self.mode == MODE_PLAY:
+                                    if self.inSequence(kachel):
+                                        self.playingStep += 1
+                                        self.sounds[0].play()
+                                        if self.playingStep == self.level:
+                                            self.done = True
+                                            
+                                    else:
+                                        self.mistake = True
+                                        self.sounds[2].play()
+                                        self.done = True
+                            else:
+                                kachel.select()
+                
+                kachel.update()
+
+            if self.mode == MODE_RANDOM:
+
+                self.randomFrame += 1
+                if self.randomFrame > RANDOM_FRAMES:
+                    self.initRandomSequence()
+
+
+            elif self.mode == MODE_SHOW:
+                self.curFrame +=1
+                if self.curFrame >= self.maxFrame:
+                    self.showing = False
+
+                for i in self.randomSequence:
+                    self.kachelarray[i].activate()
+
+
+            
+        
+    def draw(self):
+        for kachel in self.kachelarray:
+            kachel.draw()

simongame/hud.py

@@ -0,0 +1,133 @@
+import pygame
+from pygame.locals import *
+import tools
+from button import *
+
+#hud-Modes:
+HUD_MODE_MAINMENU = 0
+HUD_MODE_PLAY = 1
+HUD_MODE_GAMEOVER = 2
+
+#bissl wat zur GUI:
+SIDE_SPACING = 30
+BUTTON_HEIGTH = 50
+COLOR_FADE_FACTOR = 0.1
+
+class hud(object):
+    def __init__(self,posRect,mouse,font):
+        self.posRect = posRect
+        self.mode = HUD_MODE_MAINMENU
+        self.font = font
+
+        #Die Buttons:
+        playRect = (posRect[0]+SIDE_SPACING,posRect[1]+posRect[3]/5,posRect[2]-2*SIDE_SPACING,BUTTON_HEIGTH)
+        self.play = button(mouse,playRect,(0.0,1.0,0.0),"Los gehts!",font)
+        exitRect = (posRect[0]+SIDE_SPACING,posRect[1]+posRect[3]/5+2*BUTTON_HEIGTH,posRect[2]-2*SIDE_SPACING,BUTTON_HEIGTH)
+        self.exit = button(mouse,exitRect,(1.0,0.0,0.0),"Tschau mit V!",font)
+
+        okRect = (posRect[0]+SIDE_SPACING,posRect[3]/2+100,posRect[2]-2*SIDE_SPACING,BUTTON_HEIGTH)
+        self.ok = button(mouse,okRect,(0.0,1.0,0.0),"okay dokay",font)
+
+        self.bgColor = (0.0,0.0,0.0,1.0)
+        self.currentBgColor = self.bgColor
+
+        self.exitClicked = False
+        self.playClicked = False
+        self.okClicked = False
+
+        self.menuText = "B-)"
+        self.messageText = ";-P"
+
+    def getMode(self):
+        return self.mode
+
+    def setMode(self,mode):
+        self.mode = mode
+
+    def setBgColor(self,color):
+        self.bgColor = color
+
+    def setMessage(self,msg):
+        self.messageText = msg
+
+    def buttonUpdate(self):
+        
+        if self.exit.isClicked() == True:
+            self.exitClicked = True
+            
+
+        if self.play.isClicked() == True:
+            self.playClicked = True
+
+        if self.ok.isClicked() == True:
+            self.okClicked = True
+
+        self.play.update()
+        self.exit.update()
+        self.ok.update()
+
+    def isExitClicked(self):
+        if self.exitClicked:
+            self.exitClicked = False
+            return True
+
+        return False
+
+    def isPlayClicked(self):
+        if self.playClicked:
+            self.playClicked = False
+            return True
+
+        return False
+
+    def isOkClicked(self):
+        if self.okClicked:
+            self.okClicked = False
+            return True
+
+        return False
+
+    def update(self):
+        if self.mode == HUD_MODE_MAINMENU:
+            self.play.update()
+            self.exit.update()
+        elif self.mode == HUD_MODE_GAMEOVER:
+            self.ok.update()
+
+        self.buttonUpdate()
+
+        #hintergrundfarbe blenden:
+        r = (self.bgColor[0] - self.currentBgColor[0])*COLOR_FADE_FACTOR
+        g = (self.bgColor[1] - self.currentBgColor[1])*COLOR_FADE_FACTOR
+        b = (self.bgColor[2] - self.currentBgColor[2])*COLOR_FADE_FACTOR
+        a = (self.bgColor[3] - self.currentBgColor[3])*COLOR_FADE_FACTOR
+
+        self.currentBgColor = (self.currentBgColor[0]+ r,
+            self.currentBgColor[1]+ g,
+            self.currentBgColor[2]+ b,
+            self.currentBgColor[3]+ a)
+
+
+
+    def draw(self):
+        tools.drawRect(self.posRect,0,self.currentBgColor)
+        if self.mode == HUD_MODE_MAINMENU:
+            self.play.draw()
+            self.exit.draw()
+
+
+        if self.mode == HUD_MODE_GAMEOVER:
+            #message
+            tools.writePerFTGL("GAME OVER!",self.font,
+                (self.posRect[0]+SIDE_SPACING+10,self.posRect[3]/2-30),
+                (1.0,0.0,0.0,1.0))
+            tools.writePerFTGL(self.messageText,self.font,
+                (self.posRect[0]+SIDE_SPACING+10,self.posRect[3]/2+14),
+                (1.0,1.0,1.0,1.0))
+            self.ok.draw()
+
+        if self.mode == HUD_MODE_PLAY:
+            tools.writePerFTGL(self.messageText,self.font,
+                (self.posRect[0]+SIDE_SPACING+10,self.posRect[3]/2+14),
+                (1.0,1.0,1.0,1.0))
+

simongame/kachel.py

@@ -0,0 +1,74 @@
+import pygame
+from pygame.locals import *
+import tools
+import gitter
+
+KACHEL_ALPHA_ACTIVE = 1.0
+KACHEL_ALPHA_INACTIVE = 0.175
+KACHEL_ALPHA_SELECT = 0.5
+KACHEL_ALPHA_STEPFACTOR = 0.1
+
+
+class kachel(object):
+    def __init__(self,x,y,w,h):
+        self.x = x
+        self.y = y
+        self.w = w
+        self.h = h
+
+        #alphaverwaltung:
+        self.currentAlpha = KACHEL_ALPHA_INACTIVE
+        self.alpha = KACHEL_ALPHA_INACTIVE
+
+        self.r = 0.5-0.5/float(gitter.GITTER_W)*float(x)
+        self.g = 0.5*float(y)/float(gitter.GITTER_H)
+        self.b = float(x)/float(gitter.GITTER_W)
+
+        #verwaltungstechnisches:
+        self.isActive = False
+        self.isSelect = False
+
+    #nen paar getters und setters:
+
+    def getPos(self):
+        return (self.x,self.y,self.w,self.h)
+
+    def isActive(self):
+        return self.isActive
+
+    def isSelect(self):
+        return self.isSelect
+
+    def activate(self):
+        self.isActive = True
+        self.alpha = KACHEL_ALPHA_ACTIVE
+
+    def deactivate(self):
+        self.isActive = False
+        self.alpha = KACHEL_ALPHA_INACTIVE
+
+    def toggle(self):
+        self.isActive = not self.isActive
+        if self.isActive:
+            self.alpha = KACHEL_ALPHA_ACTIVE
+        else:
+            self.alpha = KACHEL_ALPHA_INACTIVE
+
+    def select(self):
+        if not self.isActive:
+            self.isSelect = True
+            self.alpha = KACHEL_ALPHA_SELECT
+
+    def deselect(self):
+        if not self.isActive:
+            self.isSelect = False
+            self.alpha = KACHEL_ALPHA_INACTIVE
+
+    #update:
+    def update(self):
+        self.currentAlpha += float(self.alpha - self.currentAlpha)*KACHEL_ALPHA_STEPFACTOR
+
+    def draw(self):
+        tools.drawRect((self.x*self.w+2,self.y*self.h+2,self.w-2,self.h-2),0,(self.r,self.g,self.b,self.currentAlpha))
+
+

simongame/maus.py

@@ -0,0 +1,61 @@
+import pygame
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from pygame.locals import *
+import eventmanager
+
+BUTTON_PRESSED = 0
+BUTTON_HOLD = 1
+BUTTON_RELEASED = 2
+BUTTON_INACTIVE = 3
+
+class maus(object):
+    def __init__(self):
+        self.pressed = [False,False,False]
+        self.hold = [False,False,False]
+        self.release = [False, False, False]
+        self.inactive = [True,True,True]
+
+        self.pos = (0,0)
+    
+    def update(self):
+        pressed = pygame.mouse.get_pressed()
+        self.pos = pygame.mouse.get_pos()
+        for i in range(3):
+
+            if self.pressed[i]:
+                self.pressed[i] = False
+                self.hold[i] = True
+
+            if self.release[i]:
+                self.release[i] = False
+                self.inactive[i] = True
+
+            if pressed[i]:
+                if self.inactive[i]:
+                    self.inactive[i] = False
+                    self.pressed[i] = True
+            else:
+                if self.hold[i]:
+                    self.hold[i] = False
+                    self.release[i] = True
+
+
+
+
+    def getState(self,button):
+        if self.pressed[button]:
+            
+            return BUTTON_PRESSED
+        elif self.release[button]:
+            
+            return BUTTON_RELEASED
+
+        elif self.hold[button]:
+            return BUTTON_HOLD
+
+        return BUTTON_INACTIVE
+
+    def getPos(self):
+        return self.pos
+    

simongame/pyftgl/COPYING

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

simongame/pyftgl/MANIFEST.in

@@ -0,0 +1,3 @@
+include COPYING README MANIFEST.in
+include *.py
+include *.cpp

simongame/pyftgl/README

@@ -0,0 +1,139 @@
+README for PyFTGL
+
+
+Introduction
+============
+
+FTGL is a free, open source library to enable developers to use
+arbitrary fonts in their OpenGL applications. Unlike other OpenGL font
+libraries FTGL uses standard font file formats and the Freetype font
+library to open the fonts.
+
+PyFTGL in turn wraps the functionality of FTGL into a Python module so
+that it can be used in conjunction with PyOpenGL.
+
+
+How to build
+============
+
+Prerequisites
+-------------
+
+Make sure you have the necessary libraries installed before attempting
+to build PyFTGL.
+
+   * FTGL
+     http://homepages.paradise.net.nz/henryj/code/#FTGL
+
+   * FreeType
+     http://www.freetype.org/
+
+   * boost::python
+     http://www.boost.org/
+
+
+Build
+-----
+
+$ python setup.py build
+
+
+Install
+-------
+
+$ python setup.py install
+
+
+How to use
+==========
+
+Overview
+--------
+
+To use PyFTGL, start by import it:
+
+>>> import FTGL
+
+PyFTGL supports six different rendering modes:
+
+   * Bitmap
+   * Anti-aliased pixmap
+   * Anti-aliased texture maps
+   * Outlines
+   * Polygon meshes
+   * Extruded polygon meshes
+
+The first two modes draw directly to the screen raster, the texture
+map mode draw textured quads, while the last three draw actual
+geometry.
+
+The indivdual modes are encapsulated in their respective class:
+
+   * BitmapFont
+   * PixmapFont
+   * TextureFont
+   * OutlineFont
+   * PolygonFont
+   * ExtrdFont
+
+However, the protocol for all modes are the same:
+
+>>> font = FTGL.PolygonFont("example.ttf")
+>>> font.FaceSize(24)
+True
+>>> font.line_height
+37.51171875
+>>> font.Render("foo")
+
+Obviously, you need to set up the OpenGL environment to make it
+useful. Please see the example.py script for a demonstration of
+PyFTGL.
+
+
+Classes
+-------
+
+class BitmapFont()
+class PixmapFont()
+class TextureFont()
+class OutlineFont()
+class PolygonFont()
+class ExtrdFont()
+
+  Methods defined here:
+
+  Advance(string)
+      Get the advance width for a string.
+
+  Attach(font_file_path)
+      Attach auxilliary file to font e.g font metrics.
+      Note: not all font formats implement this function.
+
+  BBox(string)
+      Get the bounding box for a string. Returns tuple.
+
+  Depth(depth)
+      Set the extrusion distance for the font. Only implemented 
+      by ExtrdFont.
+
+  FaceSize(size[, res])
+      Set the char size for the current face.
+
+  Render(string)
+      Render a string of characters.
+
+  UseDisplayList(useList)
+      Enable or disable the use of Display Lists inside FTGL.
+
+  __init__(font_file_path)
+
+  Properties defined here:
+
+  ascender
+      The global ascender height for the face.
+
+  descender
+      The global descender height for the face.
+
+  line_height
+      The line spacing for the font.

simongame/pyftgl/example.py

@@ -0,0 +1,140 @@
+#!/usr/bin/python
+
+import sys
+
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from OpenGL.GLUT import *
+
+import FTGL
+
+fonts = []
+width = 600
+height = 600
+
+def do_ortho():
+    w, h = width, height
+    glViewport(0, 0, w, h)
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity()
+    size = max(w, h) / 2.0
+    aspect = float(w) / float(h)
+    if w <= h:
+        aspect = float(h) / float(w)
+        glOrtho(-size, size, -size*aspect, size*aspect, -100000.0, 100000.0)
+    else:
+        glOrtho(-size*aspect, size*aspect, -size, size, -100000.0, 100000.0)
+    glScaled(aspect, aspect, 1.0)
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity()
+
+def draw_scene():
+    string = []
+    chars = []
+    
+    chars[:] = []
+    for i in range(1, 32):
+        chars.append(chr(i))
+    string.append("".join(chars))
+
+    chars[:] = []
+    for i in range(32, 64):
+        chars.append(chr(i))
+    string.append("".join(chars))
+
+    chars[:] = []
+    for i in range(64, 96):
+        chars.append(chr(i))
+    string.append("".join(chars))
+
+    chars[:] = []
+    for i in range(96, 128):
+        chars.append(chr(i))
+    string.append("".join(chars))
+
+    chars[:] = []
+    for i in range(128, 160):
+        chars.append(chr(i))
+    string.append("".join(chars))
+
+    chars[:] = []
+    for i in range(160, 192):
+        chars.append(chr(i))
+    string.append("".join(chars))
+
+    chars[:] = []
+    for i in range(192, 224):
+        chars.append(chr(i))
+    string.append("".join(chars))
+
+    chars[:] = []
+    for i in range(224, 256):
+        chars.append(chr(i))
+    string.append("".join(chars))
+    
+    glColor3f(1.0, 1.0, 1.0)
+
+    for i, font in enumerate(fonts):
+        x = -250.0
+        yild = 20.0
+        for j in range(0, 4):
+            y = 275.0 - i * 120.0 - j * yild
+            if i >= 3:
+                glRasterPos(x, y)
+                font.Render(string[j])
+            elif i == 2:
+                glEnable(GL_TEXTURE_2D)
+                glEnable(GL_BLEND)
+                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+                glPushMatrix()
+                glTranslatef(x, y, 0.0)
+                font.Render(string[j])
+                glPopMatrix()
+                glDisable(GL_TEXTURE_2D)
+                glDisable(GL_BLEND)
+            else:
+                glPushMatrix()
+                glTranslatef(x, y, 0.0)
+                font.Render(string[j])
+                glPopMatrix()
+            
+  
+def on_display():
+    glClear(GL_COLOR_BUFFER_BIT)
+    do_ortho()
+    draw_scene()
+    glutSwapBuffers()
+
+def on_reshape(w, h):
+    width, height = w, h
+
+def on_key(key, x, y):
+    if key == '\x1b':
+        sys.exit(1)
+
+if __name__ == '__main__':
+    glutInitWindowSize(width, height)
+    glutInit(sys.argv)
+    glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE)
+    glutCreateWindow("PyFTGL Demo")
+    glClearColor(0.0, 0.0, 0.0, 0.0)
+
+    try:
+        fonts = [
+            FTGL.OutlineFont(sys.argv[1]),
+            FTGL.PolygonFont(sys.argv[1]),
+            FTGL.TextureFont(sys.argv[1]),
+            FTGL.BitmapFont(sys.argv[1]),
+            FTGL.PixmapFont(sys.argv[1]),
+            ]
+        for font in fonts:
+            font.FaceSize(24, 72)
+    except:
+        print "usage:", sys.argv[0], "font_filename.ttf"
+        sys.exit(0)
+
+    glutDisplayFunc(on_display)
+    glutReshapeFunc(on_reshape)
+    glutKeyboardUpFunc(on_key)
+
+    glutMainLoop()

simongame/pyftgl/ftgl.cpp

@@ -0,0 +1,157 @@
+// PyFTGL
+// Copyright (c) 2007-2011, Anders Dahnielson, Luke Williams
+//
+// Contact: pyftgl@shmookey.net
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation; either
+// version 2 of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public
+// License along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+// 02111-1307  USA
+
+
+// FTGL
+#include <FTGL/ftgl.h>
+
+// Boost
+#include <boost/python.hpp>
+
+// Namespaces
+using namespace boost::python;
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// Font Wrapper
+
+template<typename base>
+class FontWrapper
+{
+public:
+	FontWrapper(const char* fontFilePath) :
+		m_font(new base(fontFilePath))
+	{ 
+		if (m_font->Error() != 0)
+			throw std::invalid_argument("Invalid argument");
+	}
+
+	bool Attach( const char* fontFilePath)
+	{ return m_font->Attach(fontFilePath); }
+
+	bool CharMap(FT_Encoding encoding)
+	{ return m_font->CharMap(encoding); }
+
+	bool FaceSize(const unsigned int size, const unsigned int res)
+	{ return m_font->FaceSize(size, res); }
+
+	bool FaceSize1(const unsigned int size)
+	{ return m_font->FaceSize(size); }
+
+	void Depth(float depth)
+	{ m_font->Depth(depth);	}
+
+	void UseDisplayList(bool useList)
+	{ m_font->UseDisplayList(useList); }
+
+	float Ascender() const
+	{ return m_font->Ascender(); }
+
+	float Descender() const
+	{ return m_font->Descender(); }
+
+	float LineHeight() const
+	{ return m_font->LineHeight(); }
+
+	tuple BBox(const char* string)
+	{
+		float llx, lly, llz, urx, ury, urz;
+		m_font->BBox(string, llx, lly, llz, urx, ury, urz);
+		return make_tuple(llx, lly, llz, urx, ury, urz);
+	}
+
+	float Advance(const char* string)
+	{ return m_font->Advance(string); }
+
+	float AdvanceKerned(const char* string, const double xSpacing)
+	{ 
+		FTPoint *kern = new FTPoint (xSpacing, 0.0, 0.0);
+		return m_font->Advance(string, -1, *kern); 
+	}
+	
+	void Render(const char* string)
+	{ m_font->Render(string); }
+
+	void RenderKerned(const char* string, const double xSpacing)
+	{ 
+		FTPoint *kern = new FTPoint (xSpacing, 0.0, 0.0);
+		m_font->Render(string, -1, *(new FTPoint ()), *kern); 
+	}
+
+private:
+	base* m_font;
+};
+
+typedef FontWrapper<FTGLOutlineFont> OutlineFontWrapper;
+typedef FontWrapper<FTGLPolygonFont> PolygonFontWrapper;
+typedef FontWrapper<FTGLExtrdFont> ExtrdFontWrapper;
+typedef FontWrapper<FTGLBitmapFont> BitmapFontWrapper;
+typedef FontWrapper<FTGLTextureFont> TextureFontWrapper;
+typedef FontWrapper<FTGLPixmapFont> PixmapFontWrapper;
+
+template<typename T>
+void export_font(const char* name)
+{
+	class_<T>(name, init<const char*>())
+		.add_property("ascender", &T::Ascender, "The global ascender height for the face.")
+		.add_property("descender", &T::Descender, "The global descender height for the face.")
+		.add_property("line_height", &T::LineHeight, "The line spacing for the font.")
+		.def("FaceSize", &T::FaceSize, "Set the char size for the current face.")
+		.def("FaceSize", &T::FaceSize1)
+		.def("Attach", &T::Attach, "Attach auxilliary file to font e.g font metrics.")
+		.def("CharMap", &T::CharMap, "Set the character map for the face.")
+		.def("Depth", &T::Depth, "Set the extrusion distance for the font.")
+		.def("UseDisplayList", &T::UseDisplayList, "Enable or disable the use of Display Lists inside FTGL.")
+		.def("BBox", &T::BBox, "Get the bounding box for a string.")
+		.def("Advance", &T::Advance, " Get the advance width for a string.")
+		.def("Advance", &T::AdvanceKerned)
+		.def("Render", &T::Render, "Render a string of characters.")
+		.def("Render", &T::RenderKerned)
+		;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// FTGL Module
+
+BOOST_PYTHON_MODULE(FTGL)
+{
+	enum_<FT_Encoding>("encoding")
+		.value("none", FT_ENCODING_NONE)
+		.value("unicode", FT_ENCODING_UNICODE)
+		.value("symbol", FT_ENCODING_MS_SYMBOL)
+		.value("latin_1", FT_ENCODING_ADOBE_LATIN_1)
+		.value("latin_2", FT_ENCODING_OLD_LATIN_2)
+		.value("sjis", FT_ENCODING_SJIS)
+		.value("gb2312", FT_ENCODING_GB2312)
+		.value("big5", FT_ENCODING_BIG5)
+		.value("wansung", FT_ENCODING_WANSUNG)
+		.value("johab", FT_ENCODING_JOHAB)
+		.value("adobe_standard", FT_ENCODING_ADOBE_STANDARD)
+		.value("adobe_expert",  FT_ENCODING_ADOBE_EXPERT)
+		.value("adobe_custom", FT_ENCODING_ADOBE_CUSTOM )
+		.value("apple_roman", FT_ENCODING_APPLE_ROMAN)
+		;
+	export_font<OutlineFontWrapper>("OutlineFont");
+	export_font<PolygonFontWrapper>("PolygonFont");
+	export_font<ExtrdFontWrapper>("ExtrdFont");
+	export_font<BitmapFontWrapper>("BitmapFont");
+	export_font<TextureFontWrapper>("TextureFont");
+	export_font<PixmapFontWrapper>("PixmapFont");
+}

simongame/pyftgl/setup.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+
+from distutils.core import setup, Extension
+
+__version__ = "0.5b"
+__author__ = "Anders Dahnielson"
+__doc__ = """Python FTGL binding
+
+FTGL is a free, open source library to enable developers to use
+arbitrary fonts in their OpenGL applications. Unlike other OpenGL font
+libraries FTGL uses standard font file formats and the Freetype font
+library to open the fonts. PyFTGL in turn wraps the functionality of
+FTGL into a Python module so that it can be used in conjunction with
+PyOpenGL."""
+
+doclines = __doc__.split("\n")
+
+##########################################################################
+## FTGL module
+
+module_ftgl_src = [
+    'ftgl.cpp',
+    ]
+
+module_ftgl_include_dirs = [
+    '/usr/include',
+    '/usr/include/freetype2',
+    ]
+
+module_ftgl_libs = [
+    'GLU',
+    'GL',
+    'freetype',
+    'z',
+    'ftgl',
+    'boost_python',
+    ]
+
+module_ftgl = Extension(
+    'FTGL',
+    module_ftgl_src,
+    include_dirs=module_ftgl_include_dirs,
+    libraries=module_ftgl_libs
+    )
+
+##########################################################################
+## setup
+
+setup(
+    name = 'PyFTGL',
+    version = __version__,
+    author = __author__,
+    author_email = 'anders@dahnielson.com',
+    maintainer = __author__,
+    maintainer_email = 'anders@dahnielson.com',
+    url = 'http://code.google.com/p/pyftgl/',
+    description = doclines[0],
+    long_description = "\n".join(doclines[2:]),
+    download_url = 'http://code.google.com/p/pyftgl/downloads/list',
+    classifiers = [
+    'Development Status :: 4 - Beta',
+    'Intended Audience :: Developers',
+    'License :: OSI Approved :: GNU General Public License (GPL)',
+    'Operating System :: POSIX',
+    'Programming Language :: C++',
+    'Programming Language :: Python',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+    ],
+    license = "GPLv2",
+    platforms = "POSIX",
+    ext_modules = [module_ftgl],
+    )

simongame/simongame.py

@@ -0,0 +1,133 @@
+#!/usr/bin/python3
+import pygame
+import numpy
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from pygame.locals import *
+import tools
+import gitter
+import maus
+import hud
+import eventmanager
+
+STARTLEVEL = 1
+
+if __name__ == "__main__":
+
+    font = tools.loadFont("GenBasR.ttf",(24,72))
+
+    pygame.init()
+    pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=128)
+
+    #sounds laden:
+
+    klick = pygame.mixer.Sound("klick.wav")
+    gong = pygame.mixer.Sound("gong.wav")
+    error = pygame.mixer.Sound("error.wav")
+
+    dinfo = pygame.display.Info()
+    video_flags = OPENGL | HWSURFACE | DOUBLEBUF | FULLSCREEN
+
+    #ein paar variablen zu den seitenverhaeltnissen:
+    SCREEN_RATIO = float(dinfo.current_w)/float(dinfo.current_h)  #16:9
+    GITTER_RATIO = float(gitter.GITTER_W)/float(gitter.GITTER_H)
+
+    FIELD_W_RATIO = (GITTER_RATIO*float(dinfo.current_h))/float(dinfo.current_w)
+
+    pygame.display.set_mode((dinfo.current_w,dinfo.current_h),video_flags)
+    tools.resize((dinfo.current_w,dinfo.current_h))
+    tools.GlInit()
+    tools.clearScreen()
+
+    eManager = eventmanager.eventmanager()
+
+    mausimaus = maus.maus()
+
+    git = gitter.gitter((dinfo.current_w*FIELD_W_RATIO,dinfo.current_h),eManager,mausimaus,(klick,gong,error))
+
+    sidebar = hud.hud((dinfo.current_w*FIELD_W_RATIO+2,2,dinfo.current_w-dinfo.current_w*FIELD_W_RATIO-4,dinfo.current_h-4),mausimaus,font)
+
+    sidebar.setBgColor((0.0,0.0,0.5,0.1))
+
+    clock = pygame.time.Clock()
+
+    curLevel = STARTLEVEL
+
+
+
+    #Hauptschleife:
+    while not sidebar.isExitClicked():
+        tools.clearScreen()
+
+        ticktime = clock.tick(40)
+
+        if sidebar.getMode() == hud.HUD_MODE_MAINMENU:
+
+            #kleiner Effekt fuer die sidebar ;)
+
+            x=mausimaus.getPos()[0]
+            y=mausimaus.getPos()[1]
+
+            if x > dinfo.current_w*FIELD_W_RATIO:
+                x = dinfo.current_w*FIELD_W_RATIO
+            r = 0.5-0.5/float(dinfo.current_w*FIELD_W_RATIO)*float(x)
+            g = 0.5*float(y)/float(dinfo.current_h)
+            b = float(x)/float(dinfo.current_w*FIELD_W_RATIO)
+
+            sidebar.setBgColor((r,g,b,0.2))
+
+            if sidebar.isPlayClicked():
+                curLevel = STARTLEVEL
+                sidebar.setMode(hud.HUD_MODE_PLAY)
+                git.setLevel(curLevel)
+                git.changeMode(gitter.MODE_SHOW)
+
+
+
+                sidebar.setBgColor((0.0,0.0,0.3,0.2))
+
+                sidebar.setMessage("Level " + str(curLevel))
+
+        elif git.getMode() == gitter.MODE_SHOW:
+            if git.readyToPlay():
+                sidebar.setBgColor((0.3,0.0,0.1,0.2))
+                git.changeMode(gitter.MODE_PLAY)
+        elif git.getMode() == gitter.MODE_PLAY:
+            if git.readyToShow():
+                if git.madeMistake():
+                    sidebar.setMode(hud.HUD_MODE_GAMEOVER)
+                    sidebar.setBgColor((1.0,0.0,0.0,0.3))
+                    sidebar.setMessage(str(curLevel-1) + " Level geschafft!")
+                    git.changeMode(gitter.MODE_RANDOM)
+                else:
+                    curLevel += 1
+                    if curLevel == gitter.GITTER_W*gitter.GITTER_H:
+                        sidebar.setMode(hud.HUD_MODE_GAMEOVER)
+                        sidebar.setMessage("alle Level geschafft!")
+                        sidebar.setBgColor((0.0,1.0,0.0,0.3))
+                        git.changeMode(gitter.MODE_RANDOM)
+                    else:
+                        git.setLevel(curLevel)
+                        git.changeMode(gitter.MODE_SHOW)
+                        sidebar.setBgColor((0.0,0.3,0.0,0.2))
+                        sidebar.setMessage("Level " + str(curLevel))
+        if sidebar.getMode() == hud.HUD_MODE_GAMEOVER:
+            if sidebar.isOkClicked():
+                sidebar.setMode(hud.HUD_MODE_MAINMENU)
+
+
+
+        git.update()
+        eventlist = eManager.getByType(KEYDOWN)
+        for event in eventlist:
+            if event.key == K_ESCAPE:
+                exit()
+        eManager.update()
+        mausimaus.update()
+        sidebar.update()
+
+        tools.drawRect((0,0,dinfo.current_w,dinfo.current_h),0,(0,0,0,1))
+        git.draw()
+        sidebar.draw()
+
+        pygame.display.flip()

simongame/startgame.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+cd ./
+python ./simongame.py

simongame/tools.py

@@ -0,0 +1,93 @@
+import pygame
+from OpenGL.GL import *
+from OpenGL.GLU import *
+from pygame.locals import *
+import FTGL
+
+#Opengl-Tools:------------------------------------------------------------------
+
+def clearScreen():
+    glClearColor(0.0,0.0,0.0,0.0)
+
+def GlInit():
+    glEnable(GL_BLEND)
+    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA)
+
+def resize((width, height)):
+    if height == 0:
+        height = 1
+    glViewport(0, 0, width, height)
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity()
+    glOrtho(0.0, width, height, 0.0, -6.0, 0.0)
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity()
+
+def drawRect(rect, depth,color):
+    glBegin(GL_QUADS)
+    glColor4f(color[0],color[1],color[2],color[3])
+
+    glVertex3f(rect[0],rect[1],depth)
+    glVertex3f(rect[0]+rect[2],rect[1],depth)
+    glVertex3f(rect[0]+rect[2],rect[1]+rect[3],depth)
+    glVertex3f(rect[0],rect[1]+rect[3],depth)
+
+    glEnd()
+
+#FTGL-Tools:--------------------------------------------------------------------
+def loadFont(filename,facesize):
+    font = FTGL.TextureFont(filename)
+    font.FaceSize(facesize[0],facesize[1])
+    return font
+
+def writePerFTGL(string,font,pos,color):
+    #glOrtho(0.0, glOrthoSize[0], 0.0, glOrthoSize[1], -6.0, 0.0)
+    
+    glPushMatrix()
+    glColor4f(color[0],color[1],color[2],color[3])
+    #so ein bissl die Matrix drehen, damit der Text nicht aufm Kopf steht :D
+    glTranslatef(pos[0], pos[1], 0.0)
+    glRotate(180,0.0,0.0,1.0)
+    glRotate(180,0.0,1.0,0.0)
+    #und rendern:
+    glRasterPos(0, 0)
+    font.Render(string)
+    #und die Matrix wieder loeschen
+    glPopMatrix()
+
+#Kollisionsabfragen:------------------------------------------------------------
+
+def is2DPointCollision(point, rect):
+    if point[0] <= rect[0] or point[0] >= rect[0]+rect[2]:
+        return False
+    elif point[1] <= rect[1] or point[1] >= rect[1] + rect[3]:
+        return False
+    return True
+
+
+if __name__ == "__main__":
+    video_flags = OPENGL | HWSURFACE | DOUBLEBUF | FULLSCREEN
+    pygame.display.set_mode((800,600),video_flags)
+    resize((800,600))
+    clearScreen()
+
+    clock = pygame.time.Clock()
+    
+    #Hauptschleife:
+    while True:
+        
+        
+        ticktime = clock.tick(20)
+        #print ticktime
+        event = pygame.event.poll()
+        if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
+            break
+       
+        
+        drawRect((0,0,200,200),0,(1,1,1,1))
+        
+        pygame.display.flip()
+
+
+
+