Remove some unused variables

raspi/mgmt/playbook.yml

@@ -2,6 +2,8 @@
   become: True
   become_user: root
   tasks:
+    - synchronize: src=../.. dest=/home/pi/sejf
+    - file: path=/etc/xdg/autostart/pprompt.desktop state=absent
     - copy: src=autostart dest=/home/pi/.config/lxsession/LXDE-pi/autostart
     - copy: src=sejf.desktop dest=/etc/xdg/autostart
     - apt: name=python-flask state=present

raspi/pySejf.py

@@ -1,22 +1,140 @@
 #!/usr/bin/python
 import os
 os.chdir(os.path.dirname(os.path.realpath(__file__)))
+os.environ['SDL_VIDEO_CENTERED'] = '1'
 
 import serial
 import webapp
+import threading
+import logging
+import socket
+import json
 
-webapp.init(serial.Serial('/dev/ttyUSB0', 115200))
-
-import random, math, pygame
+logging.basicConfig(level=logging.INFO)
+import random, pygame
 from pygame.locals import *
-from virtualKeyboard import VirtualKeyboard
 
 import threading
-from math import cos
 import time
 import RPi.GPIO as GPIO
 
+class Slide(object):
+    def __init__(self):
+        pass
+
+    def render(self, screen):
+        pass
+
+    def handle(self, ev):
+        pass
+
+    def enter(self, prev_slide):
+        return True
+
+    def exit(self, next_slide):
+        return True
+
+
+class ImageSlide(Slide):
+    def __init__(self, image):
+        self.image = image
+
+    def render(self, screen):
+        screen.fill(WHITE)
+        screen.blit(self.image, (0, 0))
+
+class FinalSlide(ImageSlide):
+    def exit(self, next_slide):
+        return False
+
+class FinalEverythingSlide(ImageSlide):
+    def enter(self, prev_slide):
+        global wall_a
+        if(wall_a):
+            win()
+            pygame.mixer.music.load("media/win.mp3")
+            pygame.mixer.music.play(MP3_LOOPS)
+            pygame.mixer.music.set_volume(1.0)
+
+        return True
+
+    def exit(self, next_slide):
+        return False
+
+class SnakeSlide(Slide):
+    def enter(self, prev_slide=None):
+        self.xs = [290, 290, 290, 290, 290];
+        self.ys = [290, 270, 250, 230, 210];
+        self.dirs = 0
+        self.score = 0
+        self.applepos = (random.randint(0, WINSIZEX), random.randint(0, WINSIZEY))
+        #s=pygame.display.set_mode((600, 600))
+        self.appleimage = IMG_APPLE
+        self.img = IMG_SNAKEBODY#pygame.Surface((20, 20))
+        #img.fill((255, 0, 0))
+        self.f = FONT_SNAKE
+        self.clock = pygame.time.Clock()
+
+        return True
+
+    def handle(self, e):
+        print(e)
+        if e.type == KEYDOWN:
+            if e.key == K_UP and self.dirs != 0:self.dirs = 2
+            elif e.key == K_DOWN and self.dirs != 2:self.dirs = 0
+            elif e.key == K_LEFT and self.dirs != 1:self.dirs = 3
+            elif e.key == K_RIGHT and self.dirs != 3:self.dirs = 1
+
+            print(self.dirs)
+
+    def render(self, screen):
+        self.clock.tick(TICK_SNAKE)
+
+        i = len(self.xs)-1
+        while i >= 2:
+            if collide(self.xs[0], self.xs[i], self.ys[0], self.ys[i], 20, 20, 20, 20):
+                die(screen, self.score)
+                self.score = 0
+                self.enter()
+
+            i-= 1
+        if collide(self.xs[0], self.applepos[0], self.ys[0], self.applepos[1], 20, 10, 20, 10):
+            self.score+=1
+            for i in range(0, SNAKE_ADDSIZE):
+                self.xs.append(700)
+                self.ys.append(700)
+            self.applepos=(random.randint(0,WINSIZEX),random.randint(0,WINSIZEY))
+
+        if self.xs[0] < 0 or self.xs[0] > WINSIZEX or self.ys[0] < 0 or self.ys[0] > WINSIZEY: 
+            die(screen, self.score)
+            score = 0
+            self.enter()
+
+        self.xs[1:] = self.xs[:-1]
+        self.ys[1:] = self.ys[:-1]
+
+        if self.dirs==0:self.ys[0] += 20
+        elif self.dirs==1:self.xs[0] += 20
+        elif self.dirs==2:self.ys[0] -= 20
+        elif self.dirs==3:self.xs[0] -= 20
+
+        #rysuj tlo
+        screen.fill(WHITE)
+        screen.blit(IMG_SNAKE, (0, 0))
+        print("drawing snake...")
+        if(self.score > SNAKE_SCORE):
+            die(screen, self.score)
+            self.enter()
+
+        for i in range(0, len(self.xs)):
+            screen.blit(self.img, (self.xs[i], self.ys[i]))
+
+        screen.blit(self.appleimage, self.applepos);
+        t=self.f.render(str(self.score), True, (0, 0, 0));
+        screen.blit(t, (10, 10));
+
 pygame.init()
+pygame.mixer.init()
 
 #gameplay
 #wynik w snake, ktory wygrywa
@@ -121,7 +239,6 @@ GPIO.output(PIN_SUC10, 1)
 GPIO.output(PIN_RELAY, 1)    
 
 WINSIZEX, WINSIZEY = 900, 680
-counter = 0
 timeSec = 0
 UP = 1
 DOWN = 3
@@ -141,22 +258,129 @@ SLIDE_DYNAMO = 5
 SLIDE_KEYPAD = 6
 SLIDE_MAZE = 7
 SLIDE_MP3 = 8
-SLIDE_KEYBOARD = 9
-SLIDE_CONGRATS = 11
+SLIDE_KEYBOARD = 11
+SLIDE_CONGRATS = 9
+SLIDE_CONGRATS_EVERYTHING = 12
 
 SLIDE_SNAKE_DEAD = 10 #to nie slajd, tylko wartosc potrzebna do resetowania snake po przegranej
 
 global slide
 #slajd poczatkowy
 slide = SLIDE_START
-slides = [SLIDE_START,SLIDE_KEY,SLIDE_POT,SLIDE_FOAMBTN,SLIDE_SNAKE,SLIDE_KEYPAD,SLIDE_MAZE,SLIDE_MP3,SLIDE_KEYBOARD,SLIDE_CONGRATS]
+slides = {
+    SLIDE_START: ImageSlide(IMG_HELLO),
+    SLIDE_KEY: ImageSlide(IMG_KEY),
+    SLIDE_POT: ImageSlide(IMG_POT),
+    SLIDE_FOAMBTN: ImageSlide(IMG_FOAMBTN),
+    SLIDE_DYNAMO: ImageSlide(IMG_DYNAMO),
+    SLIDE_KEYPAD: ImageSlide(IMG_KEYPAD),
+    SLIDE_MAZE: ImageSlide(IMG_MAZE),
+    SLIDE_MP3: ImageSlide(IMG_MP3),
+    SLIDE_CONGRATS: FinalSlide(IMG_WIN),
+    SLIDE_CONGRATS_EVERYTHING: FinalEverythingSlide(IMG_WIN),
+    SLIDE_SNAKE: SnakeSlide(),
+    }
+
+def go_to_slide(new_slide):
+    global slide
+
+    if new_slide == slide:
+        logging.warning('Same slide...')
+        return False
+
+    if slides.get(slide) and not slides[slide].exit(new_slide):
+        logging.warning('exit rejected')
+        return False
+
+    if slides.get(new_slide) and not slides[new_slide].enter(slide):
+        logging.warning('enter rejected')
+        return False
+
+    slide = new_slide
+    return True
+
+class SerialThread(threading.Thread):
+    def run(self):
+        self.logger = logging.getLogger(self.__class__.__name__)
+
+        for line in self.serial:
+            try:
+                self.handle(line)
+            except:
+                self.logger.exception('Oops...')
+
+    def handle(self, line):
+        print('Arduino said:', line)
+
+        command, _, args = line.partition(':')
+
+        if command == 'SLIDE':
+            global slide
+            go_to_slide(int(args))
+            print('Setting slide to: ', slide)
+
+class BroadcastThread(threading.Thread):
+    def run(self):
+        cs = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        cs.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        cs.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        while True:
+            global slide
+
+            print('sending')
+            cs.sendto(json.dumps({
+                'slide': slide,
+                }), ('255.255.255.255', 54545))
+            time.sleep(1)
+
+class ReceiveThread(threading.Thread):
+    states = None
+
+    def run(self):
+        self.states = {}
+
+        s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.bind(('',54545))
+        while True:
+            try:
+                msg, (host, port) = s.recvfrom(1024)
+                self.states[host] = json.loads(msg)
+                print(self.states)
+
+                if all(s['slide'] in [SLIDE_CONGRATS, SLIDE_CONGRATS_EVERYTHING]
+                       for s in self.states.values()):
+                    go_to_slide(SLIDE_CONGRATS_EVERYTHING)
+            except:
+                logging.exception('Receiver failed')
+                time.sleep(0.5)
+
+
+for c in ['/dev/ttyUSB0', '/dev/ttyACM0']:
+    try:
+        ser = serial.Serial(c, 115200)
+    except:
+        continue
+
+    print('Using ', c)
+    webapp.init(ser)
+    th = SerialThread()
+    th.serial = ser
+    th.daemon = True
+    th.start()
+
+    bth = BroadcastThread()
+    bth.daemon = True
+    bth.start()
+
+    rth = ReceiveThread()
+    rth.daemon = True
+    rth.start()
 
 
 def win():
     print "GAME OVER - YOU WIN"
     GPIO.output(PIN_RELAY, 0)
 
-        
 def signalWin(success):
     pin = 0
     if success == 4:
@@ -177,108 +401,38 @@ def signalWin(success):
 def waitForEvents():
     global slide
     print("waiting for events")
-    while 1:
-        time.sleep(0.01)
-        if GPIO.input(PIN_SET1) == 0 and slide != SLIDE_KEY:
-                print "Ardu said go to key slide"
-                slide = SLIDE_KEY
-                return
-        if GPIO.input(PIN_SET2) == 0 and slide != SLIDE_POT:
-                print "Ardu said go to pot slide"
-                slide = SLIDE_POT
-                return
-        if GPIO.input(PIN_SET3) == 0 and slide != SLIDE_FOAMBTN:
-                print "Ardu said go to foam button slide"
-                slide = SLIDE_FOAMBTN
-                return
-        if GPIO.input(PIN_SET5) == 0 and slide != SLIDE_DYNAMO:
-                print "Ardu said go to dynamo slide"
-                slide = SLIDE_DYNAMO
-                return
-        if GPIO.input(PIN_SET6) == 0 and slide != SLIDE_KEYPAD:
-                print "Ardu said go to keypad slide"
-                slide = SLIDE_KEYPAD
-                return
-        if GPIO.input(PIN_SET_WIN) == 0 and slide != SLIDE_CONGRATS:
-                print "Ardu said win"
-                slide = SLIDE_CONGRATS
-                return
+    while checkEvents():
+        clock.tick(30)
+
+def checkEvents(handler=None):
+    global slide
+
     if GPIO.input(PIN_BTNY) == 0 and slide != SLIDE_MAZE:
         print "yellow button pressed - go to maze slide"
-            slide = SLIDE_MAZE
+        go_to_slide(SLIDE_MAZE)
         return
+
     if GPIO.input(PIN_BTNG) == 0 and slide != SLIDE_MP3:
         print "green button pressed - go to mp3 slide"
-            slide = SLIDE_MP3
+        go_to_slide(SLIDE_MP3)
         return
+
     for event in pygame.event.get():
         if event.type == pygame.MOUSEBUTTONDOWN:
-                slide = SLIDE_KEYBOARD
+            go_to_slide(SLIDE_KEYBOARD)
             print("mouse event")
             return
 
         elif event.type == pygame.KEYDOWN:
             if slide != SLIDE_SNAKE:
-                    slide = SLIDE_SNAKE
-                else:
-                    slide = SLIDE_SNAKE_DEAD
+                go_to_slide(SLIDE_SNAKE)
                 print("keydown event")
                 return
 
+        if handler:
+            handler(event)
 
-def checkEvents():
-    global slide
-    if GPIO.input(PIN_SET1) == 0 and slide != SLIDE_KEY:
-            print "Ardu said go to key slide"
-            slide = SLIDE_KEY
-            return
-    if GPIO.input(PIN_SET2) == 0 and slide != SLIDE_POT:
-            print "Ardu said go to pot slide"
-            slide = SLIDE_POT
-            return
-    if GPIO.input(PIN_SET3) == 0 and slide != SLIDE_FOAMBTN:
-            print "Ardu said go to foam button slide"
-            slide = SLIDE_FOAMBTN
-            return
-    if GPIO.input(PIN_SET5) == 0 and slide != SLIDE_DYNAMO:
-            print "Ardu said go to dynamo slide"
-            slide = SLIDE_DYNAMO
-            return
-    if GPIO.input(PIN_SET6) == 0 and slide != SLIDE_KEYPAD:
-            print "Ardu said go to keypad slide"
-            slide = SLIDE_KEYPAD
-            return
-    if GPIO.input(PIN_SET_WIN) == 0 and slide != SLIDE_CONGRATS:
-            print "Ardu said win"
-            slide = SLIDE_KEYPAD
-            return
-    if GPIO.input(PIN_BTNY) == 0 and slide != SLIDE_MAZE:
-        print "yellow button pressed - go to maze slide"
-        slide = SLIDE_MAZE
-        return
-    if GPIO.input(PIN_BTNG) == 0 and slide != SLIDE_MP3: 
-        print "green button pressed - go to mp3 slide"
-        slide = SLIDE_MP3
-        return
-    for event in pygame.event.get():
-            if event.type == pygame.MOUSEBUTTONDOWN and slide != SLIDE_KEYBOARD:
-                slide = SLIDE_KEYBOARD
-                print("mouse event")
-                return 1
-            
-            elif event.type == pygame.KEYDOWN:
-                slide = SLIDE_SNAKE
-                print("keydown event")
-                return
-            else: return 0
-
-def drawSlide(n):
-    print("drawing slide:")
-    print(n)
-    screen.fill(WHITE)
-    screen.blit(slides[n], (0, 0))
-    pygame.display.flip()
-    waitForEvents()
+    return True
 
 def collide(x1, x2, y1, y2, w1, w2, h1, h2):
     if x1+w1>x2 and x1<x2+w2 and y1+h1>y2 and y1<y2+h2:return True
@@ -292,231 +446,55 @@ def die(screen, score):
     screen.blit(t, (10, 270))
     pygame.display.update()
     pygame.time.wait(2000)
+    global slide
+    slide = SLIDE_SNAKE_DEAD
     waitForEvents()
 
+############# old main
+######## CONSTANTS
+WINSIZE = [WINSIZEX,WINSIZEY]
+BLOCKSIZE = [18,18]
+UP = 1
+DOWN = 3
+RIGHT = 2
+LEFT = 4
+WHITE = [255, 255, 255]
+
+MINX = 100
+MAXX = WINSIZEX - MINX
+MINY = 100
+MAXY = WINSIZEY - MINY
+
+
+######## VARIABLES
+clock = pygame.time.Clock()
+screen = pygame.display.set_mode(WINSIZE, pygame.NOFRAME)
+pygame.display.set_caption('PozySejf')
+
+############# old main
+
+
 def main():
     global slide
     
+    passwordLetter = ''
+
     startonce = 0
-    showstartscreen = 0
     
     while startonce == 0:
         startonce = 0
-        ######## CONSTANTS
-        WINSIZE = [WINSIZEX,WINSIZEY]
-        BLOCKSIZE = [18,18]
-        UP = 1
-        DOWN = 3
-        RIGHT = 2
-        LEFT = 4
-        WHITE = [255, 255, 255]
-        
-        MINX = 100
-        MAXX = WINSIZEX - MINX
-        MINY = 100
-        MAXY = WINSIZEY - MINY
-        
-        
-        SNAKESTEP = 20
-        TRUE = 1
-        FALSE = 0
-        
-
-        ######## VARIABLES
-        direction = RIGHT # 1=up,2=right,3=down50,4=left
-        snakexy = [300,400]
-        snakelist = [[300,400],[280,400],[260,400]]
-        counter = 0
-        score = 0
-        appleonscreen = 0
-        applexy = [0,0]
-        newdirection = RIGHT
-        snakedead = FALSE
-        gameregulator = 6
-        gamepaused = 0
-        growsnake = 0  # added to grow tail by two each time 
-        snakegrowunit = 2 # added to grow tail by two each time
-        clock = pygame.time.Clock()
-        screen = pygame.display.set_mode(WINSIZE)#FULLSCREEN)
-        #screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
-        pygame.display.set_caption('PozySejf')
-        pygame.FULLSCREEN
-        #screen = display.set_mode([1024,768], FULLSCREEN)
-        #screen.fill(BLACK)
-        dynamoValSPI = [0,0,0]
-        dynamoRectY = [50, 50, 50]
-        dynamoRectX = 50
-        dynamoXpos = [-100, 0, 100]
-        distanceDynamoRect = 300
-        textInputDotNumber = 0
-        pushButtonNumber = 100
-        
-        valueSound = 100
-
-        passwordLetter = ''
         #### show initial start screen
         ### every while loop for each slide
-        while slide == SLIDE_START:
-            print("showing slide 0")
-            screen.fill(WHITE)
-            screen.blit(IMG_HELLO, (0, 0))
+
+        if slide in slides:
+            slides[slide].render(screen)
+            checkEvents(slides[slide].handle)
             pygame.display.flip()
-            pygame.time.wait(5000)
-            waitForEvents()
-            break
-            
-        while slide == SLIDE_KEY:
-            print("showing slide 1 - key")
-            screen.fill(WHITE)
-            screen.blit(IMG_KEY, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-           
-        while slide == SLIDE_POT:
-            print("showing slide 2 - pot")
-            screen.fill(WHITE)
-            screen.blit(IMG_POT, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-        
-        while slide == SLIDE_FOAMBTN:
-            print("showing slide 3 - foam button")
-            screen.fill(WHITE)
-            screen.blit(IMG_FOAMBTN, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-        
-        while slide == SLIDE_SNAKE: ## snake
-            print("snake is starting...")
-            
-            xs = [290, 290, 290, 290, 290];
-            ys = [290, 270, 250, 230, 210];
-            dirs = 0
-            score = 0
-            applepos = (random.randint(0, WINSIZEX), random.randint(0, WINSIZEY))
-            pygame.init()
-            #s=pygame.display.set_mode((600, 600))
-            appleimage = IMG_APPLE
-            img = IMG_SNAKEBODY#pygame.Surface((20, 20))
-            #img.fill((255, 0, 0))
-            f = FONT_SNAKE
-            clock = pygame.time.Clock()
-            while slide == SLIDE_SNAKE:
-                    clock.tick(TICK_SNAKE)
-                    if GPIO.input(PIN_SET1) == 0 and slide != SLIDE_KEY:
-                            print "Ardu said go to key slide"
-                            slide = SLIDE_KEY
-                            break
-                    if GPIO.input(PIN_SET2) == 0 and slide != SLIDE_POT:
-                            print "Ardu said go to pot slide"
-                            slide = SLIDE_POT
-                            break
-                    if GPIO.input(PIN_SET3) == 0 and slide != SLIDE_FOAMBTN:
-                            print "Ardu said go to foam button slide"
-                            slide = SLIDE_FOAMBTN
-                            break
-                    if GPIO.input(PIN_SET5) == 0 and slide != SLIDE_DYNAMO:
-                            print "Ardu said go to dynamo slide"
-                            slide = SLIDE_DYNAMO
-                            break
-                    if GPIO.input(PIN_SET6) == 0 and slide != SLIDE_KEYPAD:
-                            print "Ardu said go to keypad slide"
-                            slide = SLIDE_KEYPAD
-                            break
-                    if GPIO.input(PIN_SET_WIN) == 0 and slide != SLIDE_CONGRATS:
-                            print "Ardu said win"
-                            slide = SLIDE_KEYPAD
-                            break
-                    if GPIO.input(PIN_BTNY) == 0:
-                        print "yellow button pressed - go to maze slide"
-                        slide = SLIDE_MAZE
-                        break
-                    if GPIO.input(PIN_BTNG) == 0: 
-                        print "green button pressed - go to mp3 slide"
-                        slide = SLIDE_MP3
-                        break
-                    for e in pygame.event.get():
-                            #if e.type == QUIT:
-                            #   sys.exit(0) #quit - nie chcemy miec mozliwosci wyjscia z aplikacji
-                            if e.type == KEYDOWN:
-                                    if e.key == K_UP and dirs != 0:dirs = 2
-                                    elif e.key == K_DOWN and dirs != 2:dirs = 0
-                                    elif e.key == K_LEFT and dirs != 1:dirs = 3
-                                    elif e.key == K_RIGHT and dirs != 3:dirs = 1
-                            elif e.type == pygame.MOUSEBUTTONDOWN:
-                                slide = SLIDE_KEYBOARD
-                                print("mouse event")
-                                break
-                    i = len(xs)-1
-                    while i >= 2:
-                            if collide(xs[0], xs[i], ys[0], ys[i], 20, 20, 20, 20):
-                                die(screen, score)
-                                score = 0
-                                break
-                            i-= 1
-                    if collide(xs[0], applepos[0], ys[0], applepos[1], 20, 10, 20, 10):
-                        score+=1
-                        for i in range(0, SNAKE_ADDSIZE):
-                            xs.append(700)
-                            ys.append(700)
-                        applepos=(random.randint(0,WINSIZEX),random.randint(0,WINSIZEY))
-                    if xs[0] < 0 or xs[0] > WINSIZEX or ys[0] < 0 or ys[0] > WINSIZEY: 
-                        die(screen, score)
-                        score = 0
-                        break 
-                    i = len(xs)-1
-                    while i >= 1:
-                            xs[i] = xs[i-1];ys[i] = ys[i-1];i -= 1
-                    if dirs==0:ys[0] += 20
-                    elif dirs==1:xs[0] += 20
-                    elif dirs==2:ys[0] -= 20
-                    elif dirs==3:xs[0] -= 20    
-                    #rysuj tlo
-                    screen.fill(WHITE)
-                    screen.blit(IMG_SNAKE, (0, 0))  
-                    print("drawing snake...")
-                    if(score > SNAKE_SCORE):
-                        die(screen, score)
-                        break
-                    for i in range(0, len(xs)):
-                            screen.blit(img, (xs[i], ys[i]))
-                    screen.blit(appleimage, applepos);t=f.render(str(score), True, (0, 0, 0));screen.blit(t, (10, 10));pygame.display.update()
+            clock.tick(15)
 
         while slide == SLIDE_SNAKE_DEAD:
             print("resetting snake.")
             slide = SLIDE_SNAKE
-        while slide == SLIDE_DYNAMO:
-            print("showing slide 5 - dynamo")
-            screen.fill(WHITE)
-            screen.blit(IMG_DYNAMO, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break            
-        while slide == SLIDE_KEYPAD:
-            print("showing slide 6 - drawer keypad")
-            screen.fill(WHITE)
-            screen.blit(IMG_KEYPAD, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-        while slide == SLIDE_MAZE:
-            print("showing slide 7 - maze")
-            screen.fill(WHITE)
-            screen.blit(IMG_MAZE, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break
-        
-        while slide == SLIDE_MP3:
-            print("showing slide 8 - mp3 player")
-            screen.fill(WHITE)
-            screen.blit(IMG_MP3, (0, 0))
-            pygame.display.flip()
-            waitForEvents()
-            break   
 
         while slide == SLIDE_KEYBOARD: ## keyboard
             #print("checking events")
@@ -587,23 +565,6 @@ def main():
 
             pygame.display.flip()
 
-        while slide == SLIDE_CONGRATS: ## congratulation
-            print("showing slide 10 - win")
-            screen.fill(WHITE)
-            screen.blit(IMG_WIN, (0, 0))          
-            pygame.display.flip()
-            if(wall_a):
-                win()
-                pygame.mixer.init()
-                pygame.mixer.music.load("media/win.mp3")
-                pygame.mixer.music.play(MP3_LOOPS)
-                pygame.mixer.music.set_volume(1.0)
-                while pygame.mixer.music.get_busy() == True:
-                    continue
-                while 1:
-                    print "you win."
-            waitForEvents()
-            
 if __name__ == '__main__':
     main()