pack functions in class

1 files changed, 213 insertions, 217 deletions

diff --git a/kuku.py b/kuku.py
index 50da68b..712203e 100755
--- a/kuku.py
+++ b/kuku.py
@@ -54,34 +54,74 @@ scale_y = 1.0
 
 
 dirtyrects = [] # list of update_rects
-class Img: pass # container for images
-
-class StopGame(Exception):
-    pass
-
-
-#Initialize with configs
-
-#Initialize questions - need to do lazy loading to speed up game init
-question_lists = []
-qfIO = question.QuestionFileIO()
-for question_file in QUESTION_FILES:
-    try:
-        #print question_file
-        question_list = qfIO.Read_questions(data_path(question_file))
-    except question.ParseError:
-        print 'Problem parsing file, using random questions.'
-        qs = []
-        for j in range(100):
-            q = (random.randint(0,9),
-                 random.randint(0,9))
-            question_string = '%i x %i = ?' % q
-            answer = '%i' % (q[0]*q[1])
-            qs.append(question.Question(question_string,
-                                                     answer))
-            question_list = question.QuestionList(qs)
-    question_lists.append(question_list)
-question_group = question.QuestionGroup(question_lists)
+
+
+# container for images
+class Images():
+
+    def __init__(self, scale_x, scale_y):
+
+        # Load player images
+        kuku = load_image('kuku_default.png',1)
+        kuku_peck = load_image('kuku_pecking.png',1)
+        kuku_stunned = load_image('kuku_stunned.png',1)
+        kuku_happy = load_image('kuku_happy.png',1)
+        kuku_game_start = load_image('kuku_startpage.png',1)
+        kuku_game_over = load_image('kuku_endpage.png',1)
+        kuku_game_win = load_image('kuku_win.png',1)
+        kuku_num_correct = load_image('kuku_num_correct.png',1)
+        kuku_high_score = load_image('kuku_high_score.png',1)
+        kuku_clock = load_image('kuku_clock.png',1)
+
+        self.game_start = pygame.transform.scale(kuku_game_start,
+                                                (int(scale_x*kuku_game_start.get_rect().width),
+                                                 int(scale_y*kuku_game_start.get_rect().height)))
+
+        self.game_over = pygame.transform.scale(kuku_game_over,
+                                                (int(scale_x*kuku_game_over.get_rect().width),
+                                                 int(scale_y*kuku_game_over.get_rect().height)))
+
+        self.game_win = pygame.transform.scale(kuku_game_win,
+                                                (int(scale_x*kuku_game_win.get_rect().width),
+                                                 int(scale_y*kuku_game_win.get_rect().height)))
+
+        self.player_right = pygame.transform.scale(kuku,
+                                                  (int(scale_x*kuku.get_rect().width),
+                                                  int(scale_y*kuku.get_rect().height)))
+        self.player_left = pygame.transform.flip(self.player_right,1,0)
+        self.peck_right = pygame.transform.scale(kuku_peck,
+                                (int(scale_x*kuku_peck.get_rect().width),
+                                int(scale_y*kuku_peck.get_rect().height)))
+        self.peck_left = pygame.transform.flip(self.peck_right,1,0)
+
+        #change this to get image correct
+        self.lives = pygame.transform.scale(kuku_peck,
+                                (int(scale_x*kuku_peck.get_rect().width),
+                                int(scale_y*kuku_peck.get_rect().height)))
+
+        self.correct = pygame.transform.scale(kuku_num_correct,
+                                (int(scale_x*kuku_num_correct.get_rect().width),
+                                 int(scale_y*kuku_num_correct.get_rect().height)))
+
+        self.high_score = pygame.transform.scale(kuku_high_score,
+                                (int(scale_x*kuku_high_score.get_rect().width),
+                                 int(scale_y*kuku_high_score.get_rect().height)))
+
+        #clock
+        self.timer =   pygame.transform.scale(kuku_clock,
+                                (int(scale_x*kuku_clock.get_rect().width),
+                                 int(scale_y*kuku_clock.get_rect().height)))
+
+        self.stunned_right = pygame.transform.scale(kuku_stunned,
+                                                (int(scale_x*kuku_stunned.get_rect().width),
+                                                 int(scale_y*kuku_stunned.get_rect().height)))
+        self.stunned_left = pygame.transform.flip(self.stunned_right,1,0)
+
+        self.happy_right = pygame.transform.scale(kuku_happy,
+                                                   (int(scale_x*kuku_happy.get_rect().width),
+                                                    int(scale_y*kuku_happy.get_rect().height)))
+        self.happy_left = pygame.transform.flip(self.happy_right,1,0)
+
 
 class State(object):
     """State object
@@ -137,9 +177,6 @@ class State(object):
         # print self
 
 
-
-
-
 class Actor:
     "An enhanced sort of sprite class"
     def __init__(self, image):
@@ -169,13 +206,15 @@ class Actor:
 
 class Player(Actor):
     "Cheer for our hero"
-    def __init__(self,grid):
+    def __init__(self,grid, img):
         """grid is the grid the player lives on"""
-        Actor.__init__(self, Img.player_right)
+        Actor.__init__(self, img.player_right)
         self.alive = 1
         self.grid = grid
         self.grid_position = self.grid.get_center_position()
         self.set_rect_position(self.image)
+        self.img_player_left = img.player_left
+        self.img_player_right = img.player_right
 
     def set_rect_position(self,cimage):
         """set_rect_position based on grid_position"""
@@ -207,9 +246,9 @@ class Player(Actor):
 
         #change image to reflect right and left
         if x_step < 0:
-            self.set_image(Img.player_left)
+            self.set_image(self.img_player_left)
         elif x_direction > 0:
-            self.set_image(Img.player_right)
+            self.set_image(self.img_player_right)
             step = 1
         #elif y_direction != 0:
             #self.set_image(Img.player_right)
@@ -393,9 +432,6 @@ class Time(object):
         return self.number
 
 
-
-
-
 class Score(object):
     """keeps Score"""
     def __init__(self,number,image,screen,font):
@@ -518,74 +554,41 @@ class Lives(object):
         self.number = number
         self.update = 1
 
-def game_over(screen,gridsize,font):
-    """the game over screen"""
-    screen.fill((255,255,255))
-    vec = (screen.get_rect().center[0]-Img.game_over.get_rect().center[0],
-           screen.get_rect().center[1]-Img.game_over.get_rect().center[1],
-    )
-    r = Img.game_over.get_rect()
-    r = r.move(vec[0],vec[1])
-    screen.blit(Img.game_over,r)
-    pygame.display.update()
-    while True:
-        # Pump GTK messages.
-        while gtk.events_pending():
-            gtk.main_iteration()
-        events = pygame.event.get()
-        for evt in events:
-            if evt.type == pygame.KEYDOWN:
-                qa,num_players,score,time_clock = game_start(screen,gridsize,font)
-                return (qa,num_players,score,time_clock)
-
-def game_win(screen,gridsize,font,state):
-    """the game over screen"""
-    screen.fill((255,255,255))
-    vec = (screen.get_rect().center[0]-Img.game_win.get_rect().center[0],
-           screen.get_rect().center[1]-Img.game_win.get_rect().center[1],
-    )
-    r = Img.game_win.get_rect()
-    r = r.move(vec[0],vec[1])
-    screen.blit(Img.game_win,r)
-    pygame.display.update()
-    # print 'win!!', state
-    while True:
-        # Pump GTK messages.
-        while gtk.events_pending():
-            gtk.main_iteration()
-        events = pygame.event.get()
-        for evt in events:
-            if evt.type == pygame.KEYDOWN:
-                qa,num_players,score,time_clock = game_start(screen,gridsize,font,started=1)
-                score.set(state.score)
-                return (qa,num_players,score,time_clock)
-
-
-def game_start(screen,gridsize,font,started=1):
-    """the game over screen"""
-    # Start music
-    pygame.mixer.music.load(data_path('kuku_slow.ogg'))
-    pygame.mixer.music.play(-1,0.0)
-
-    if not started:
+
+class KukuActivity():
+
+    def __init__(self):
+        #Initialize questions - need to do lazy loading to speed up game init
+        self.question_lists = []
+        qfIO = question.QuestionFileIO()
+        for question_file in QUESTION_FILES:
+            try:
+                #print question_file
+                question_list = qfIO.Read_questions(data_path(question_file))
+            except question.ParseError:
+                print 'Problem parsing file, using random questions.'
+                qs = []
+                for j in range(100):
+                    q = (random.randint(0,9),
+                         random.randint(0,9))
+                    question_string = '%i x %i = ?' % q
+                    answer = '%i' % (q[0]*q[1])
+                    qs.append(question.Question(question_string,
+                                                             answer))
+                    question_list = question.QuestionList(qs)
+            self.question_lists.append(question_list)
+        self.question_group = question.QuestionGroup(self.question_lists)
+
+    def game_over(self, screen, gridsize, font):
+        """the game over screen"""
         screen.fill((255,255,255))
-        vec = (screen.get_rect().center[0]-Img.game_start.get_rect().center[0],
-               screen.get_rect().center[1]-Img.game_start.get_rect().center[1],
+        vec = (screen.get_rect().center[0]-self.Img.game_over.get_rect().center[0],
+               screen.get_rect().center[1]-self.Img.game_over.get_rect().center[1],
         )
-        r = Img.game_start.get_rect()
+        r = self.Img.game_over.get_rect()
         r = r.move(vec[0],vec[1])
-        screen.blit(Img.game_start,r)
-
-        message = _('Begin!')
-        text = font.render(message,1,(10,10,10))
-        twidth = text.get_rect().width
-        theight = text.get_rect().height
-        tlcorner = screen.get_rect().center
-        textpos = (tlcorner[0]-twidth/2, tlcorner[1])
-
-        screen.blit(text,textpos)
-        pygame.display.flip()
-
+        screen.blit(self.Img.game_over,r)
+        pygame.display.update()
         while True:
             # Pump GTK messages.
             while gtk.events_pending():
@@ -593,55 +596,106 @@ def game_start(screen,gridsize,font,started=1):
             events = pygame.event.get()
             for evt in events:
                 if evt.type == pygame.KEYDOWN:
-                    qa,num_players,score,time_clock = reset_board(screen,gridsize,font)
+                    qa,num_players,score,time_clock = self.game_start(screen,gridsize,font)
                     return (qa,num_players,score,time_clock)
-    else:
-        started = 1
-        qa,num_players,score,time_clock = reset_board(screen,gridsize,font)
-        return (qa,num_players,score,time_clock)
-
 
+    def game_win(self, screen, gridsize, font, state):
+        """the game over screen"""
+        screen.fill((255,255,255))
+        vec = (screen.get_rect().center[0]-self.Img.game_win.get_rect().center[0],
+               screen.get_rect().center[1]-self.Img.game_win.get_rect().center[1],
+        )
+        r = self.Img.game_win.get_rect()
+        r = r.move(vec[0],vec[1])
+        screen.blit(self.Img.game_win,r)
+        pygame.display.update()
+        # print 'win!!', state
+        while True:
+            # Pump GTK messages.
+            while gtk.events_pending():
+                gtk.main_iteration()
+            events = pygame.event.get()
+            for evt in events:
+                if evt.type == pygame.KEYDOWN:
+                    qa,num_players,score,time_clock = self.game_start(screen,gridsize,font,started=1)
+                    score.set(state.score)
+                    return (qa,num_players,score,time_clock)
 
-def reset_board(screen,gridsize,font,
-                num_players=None,score=None,
-                time_clock=None):
-    """docstring for reset_board"""
-    # Stop all sounds
-    #pygame.mixer.stop()
 
-    # # Start music
-    # pygame.mixer.music.load(data_path('kuku_slow.ogg'))
-    # pygame.mixer.music.play(-1,0.0)
+    def game_start(self, screen, gridsize, font, started=1):
+        """the game over screen"""
+        # Start music
+        pygame.mixer.music.load(data_path('kuku_slow.ogg'))
+        pygame.mixer.music.play(-1,0.0)
+
+        if not started:
+            screen.fill((255,255,255))
+            vec = (screen.get_rect().center[0]-self.Img.game_start.get_rect().center[0],
+                   screen.get_rect().center[1]-self.Img.game_start.get_rect().center[1],
+            )
+            r = self.Img.game_start.get_rect()
+            r = r.move(vec[0],vec[1])
+            screen.blit(self.Img.game_start,r)
+
+            message = _('Begin!')
+            text = font.render(message,1,(10,10,10))
+            twidth = text.get_rect().width
+            theight = text.get_rect().height
+            tlcorner = screen.get_rect().center
+            textpos = (tlcorner[0]-twidth/2, tlcorner[1])
+
+            screen.blit(text,textpos)
+            pygame.display.flip()
+
+            while True:
+                # Pump GTK messages.
+                while gtk.events_pending():
+                    gtk.main_iteration()
+                events = pygame.event.get()
+                for evt in events:
+                    if evt.type == pygame.KEYDOWN:
+                        qa,num_players,score,time_clock = self.reset_board(screen,gridsize,font)
+                        return (qa,num_players,score,time_clock)
+        else:
+            started = 1
+            qa,num_players,score,time_clock = self.reset_board(screen,gridsize,font)
+            return (qa,num_players,score,time_clock)
 
-    question_list = question_group.next()
-    q = question_list.next()
-    # print q.a_string, q.a_type
-    qa = QuestionAnswer(gridsize,q,
-                        answer_pool=question_list.get_all_answers())
 
-    if not num_players:
-        num_players = Lives(PLAYER_LIVES,Img.lives,screen,font)
-    else:
-        num_players.update = 1
 
-    if not score:
-        score = Score(0,Img.correct,screen,font)
-    else:
-        score.update = 1
+    def reset_board(self, screen, gridsize, font,
+                    num_players=None, score=None,
+                    time_clock=None):
+        """docstring for reset_board"""
+        # Stop all sounds
+        #pygame.mixer.stop()
 
-    if not time_clock:
-        time_clock = Time(GAME_TIME,Img.timer,screen,font)
+        # # Start music
+        # pygame.mixer.music.load(data_path('kuku_slow.ogg'))
+        # pygame.mixer.music.play(-1,0.0)
 
-    screen.fill((255,255,255))
-    pygame.display.update()
-    return (qa,num_players,score,time_clock)
+        question_list = self.question_group.next()
+        q = question_list.next()
+        # print q.a_string, q.a_type
+        qa = QuestionAnswer(gridsize,q,
+                            answer_pool=question_list.get_all_answers())
 
+        if not num_players:
+            num_players = Lives(PLAYER_LIVES,self.Img.lives,screen,font)
+        else:
+            num_players.update = 1
 
-class KukuActivity():
+        if not score:
+            score = Score(0,self.Img.correct,screen,font)
+        else:
+            score.update = 1
 
-    def __init__(self):
-        s = None
+        if not time_clock:
+            time_clock = Time(GAME_TIME,self.Img.timer,screen,font)
 
+        screen.fill((255,255,255))
+        pygame.display.update()
+        return (qa,num_players,score,time_clock)
 
     def run(self):
         """main pygame loop"""
@@ -687,7 +741,7 @@ class KukuActivity():
                 scale_y = h/825.0
                 scale_x = scale_y
                 ancho = (1200.0*scale_y)
-             SCREENRECT = Rect(0,0,int(ancho),int(altura))
+            SCREENRECT = Rect(0,0,int(ancho),int(altura))
 
         # make background
         background = pygame.Surface(SCREENRECT.size).convert()
@@ -716,85 +770,27 @@ class KukuActivity():
         kuku_lose = pygame.mixer.Sound(data_path('kuku_death.ogg'))
         kuku_win = pygame.mixer.Sound(data_path('kuku_win.ogg'))
 
+        # load images
+        self.Img = Images(scale_x, scale_y)
+
         # create a font instance
         font = pygame.font.Font(None, FONT_SIZE)
 
         # set the gridsize
         gridsize = (GRID_SIZE,GRID_SIZE)
 
-        # Load player images
-        kuku = load_image('kuku_default.png',1)
-        kuku_peck = load_image('kuku_pecking.png',1)
-        kuku_stunned = load_image('kuku_stunned.png',1)
-        kuku_happy = load_image('kuku_happy.png',1)
-        kuku_game_start = load_image('kuku_startpage.png',1)
-        kuku_game_over = load_image('kuku_endpage.png',1)
-        kuku_game_win = load_image('kuku_win.png',1)
-        kuku_num_correct = load_image('kuku_num_correct.png',1)
-        kuku_high_score = load_image('kuku_high_score.png',1)
-        kuku_clock = load_image('kuku_clock.png',1)
-
-        Img.game_start = pygame.transform.scale(kuku_game_start,
-                                                (int(scale_x*kuku_game_start.get_rect().width),
-                                                 int(scale_y*kuku_game_start.get_rect().height)))
-
-        Img.game_over = pygame.transform.scale(kuku_game_over,
-                                                (int(scale_x*kuku_game_over.get_rect().width),
-                                                 int(scale_y*kuku_game_over.get_rect().height)))
-
-        Img.game_win = pygame.transform.scale(kuku_game_win,
-                                                (int(scale_x*kuku_game_win.get_rect().width),
-                                                 int(scale_y*kuku_game_win.get_rect().height)))
-
-        Img.player_right = pygame.transform.scale(kuku,
-                                                  (int(scale_x*kuku.get_rect().width),
-                                                  int(scale_y*kuku.get_rect().height)))
-        Img.player_left = pygame.transform.flip(Img.player_right,1,0)
-        Img.peck_right = pygame.transform.scale(kuku_peck,
-                                (int(scale_x*kuku_peck.get_rect().width),
-                                int(scale_y*kuku_peck.get_rect().height)))
-        Img.peck_left = pygame.transform.flip(Img.peck_right,1,0)
-
-        #change this to get image correct
-        Img.lives = pygame.transform.scale(kuku_peck,
-                                (int(scale_x*kuku_peck.get_rect().width),
-                                int(scale_y*kuku_peck.get_rect().height)))
-
-        Img.correct = pygame.transform.scale(kuku_num_correct,
-                                (int(scale_x*kuku_num_correct.get_rect().width),
-                                 int(scale_y*kuku_num_correct.get_rect().height)))
-
-        Img.high_score = pygame.transform.scale(kuku_high_score,
-                                (int(scale_x*kuku_high_score.get_rect().width),
-                                 int(scale_y*kuku_high_score.get_rect().height)))
-
-        #clock
-        Img.timer =   pygame.transform.scale(kuku_clock,
-                                (int(scale_x*kuku_clock.get_rect().width),
-                                 int(scale_y*kuku_clock.get_rect().height)))
-
-        Img.stunned_right = pygame.transform.scale(kuku_stunned,
-                                                (int(scale_x*kuku_stunned.get_rect().width),
-                                                 int(scale_y*kuku_stunned.get_rect().height)))
-        Img.stunned_left = pygame.transform.flip(Img.stunned_right,1,0)
-
-        Img.happy_right = pygame.transform.scale(kuku_happy,
-                                                   (int(scale_x*kuku_happy.get_rect().width),
-                                                    int(scale_y*kuku_happy.get_rect().height)))
-        Img.happy_left = pygame.transform.flip(Img.happy_right,1,0)
-
-
+        
         #create high_score
-        high_score = HighScore(state.high_score,Img.high_score,screen,font)
+        high_score = HighScore(state.high_score,self.Img.high_score,screen,font)
 
 
         # print Img.player_right.get_rect().height, Img.stunned_right.get_rect().height
         #create player
         grid = Grid(SCREENRECT,gridsize, scale_x)
-        player = Player(grid)
+        player = Player(grid, self.Img)
 
         # qa,num_players = reset_board(screen,gridsize,font)
-        qa,num_players,score,time_clock = game_start(screen,gridsize,font,started=0)
+        qa,num_players,score,time_clock = self.game_start(screen,gridsize,font,started=0)
 
         # keep track of time
         clock = pygame.time.Clock()
@@ -813,11 +809,11 @@ class KukuActivity():
             time += delta
             if time > 1000:
                 time = 0
-                Img.correct,screen,font
+                #self.Img.correct,screen,font
                 time_clock.add(-1)
                 if time_clock.get_ticks() == 0:
                     num_players.kill()
-                    qa,num_players,score,time_clock = reset_board(screen,gridsize,
+                    qa,num_players,score,time_clock = self.reset_board(screen,gridsize,
                                                        font,
                                                        num_players=num_players,
                                                        score=score)
@@ -840,7 +836,7 @@ class KukuActivity():
                         #then set pecking image, then only update
                         #these dirtyrects, then delay
                         animate_dirtyrects = [player.erase(screen,grid.get_tile(x,y).get_background())]
-                        player.set_image(Img.peck_right)
+                        player.set_image(self.Img.peck_right)
                         animate_dirtyrects.append(player.draw(screen))
                         pygame.display.update(animate_dirtyrects)
                         pygame.time.wait(200)
@@ -855,11 +851,11 @@ class KukuActivity():
                             time = 0
 
                             if actor_facing == 1:
-                                player.set_image(Img.happy_right)
+                                player.set_image(self.Img.happy_right)
                             else:
-                                player.set_image(Img.happy_left)
+                                player.set_image(self.Img.happy_left)
                             #pygame.time.wait(850)
-                            qa,num_players,score,time_clock = reset_board(screen,gridsize,
+                            qa,num_players,score,time_clock = self.reset_board(screen,gridsize,
                                                                font,
                                                                num_players=num_players,
                                                                score=score,
@@ -884,11 +880,11 @@ class KukuActivity():
 
 
                             if actor_facing == 1:
-                                player.set_image(Img.stunned_right)
-                                player.set_rect_position(Img.stunned_right)
+                                player.set_image(self.Img.stunned_right)
+                                player.set_rect_position(self.Img.stunned_right)
                             else:
-                                player.set_image(Img.stunned_left)
-                                player.set_rect_position(Img.stunned_left)
+                                player.set_image(self.Img.stunned_left)
+                                player.set_rect_position(self.Img.stunned_left)
 
                     
                     elif evt.key == pygame.K_LEFT or evt.key == pygame.K_KP4:
@@ -911,7 +907,7 @@ class KukuActivity():
                 # qa,num_players = reset_board(screen,gridsize,font)
                 pygame.mixer.music.fadeout(2000)
                 kuku_lose.play()
-                qa,num_players,score,time_clock = game_over(screen,gridsize,font)
+                qa,num_players,score,time_clock = self.game_over(screen,gridsize,font)
                 state.update(lives=num_players.get_lives(),
                              score=score.get_score(),
                              time =time_clock.get_ticks())
@@ -923,7 +919,7 @@ class KukuActivity():
                 pygame.mixer.music.fadeout(2000)
                 kuku_win.play()
                 pygame.mixer.music
-                qa,num_players,score,time_clock = game_win(screen,gridsize,font,state)
+                qa,num_players,score,time_clock = self.game_win(screen,gridsize,font,state)
                 state.update(lives=num_players.get_lives(),
                              score=score.get_score(),
                              time =time_clock.get_ticks())