Merge branch 'master' of git.sugarlabs.org:hittheballs/hittheballs

3 files changed, 78 insertions, 46 deletions

diff --git a/gpl-3.0.txt b/COPYING
index 94a9ed0..94a9ed0 100644
--- a/gpl-3.0.txt
+++ b/COPYING
diff --git a/elements_painter.py b/elements_painter.py
index 63e01a6..e32bf33 100644
--- a/elements_painter.py
+++ b/elements_painter.py
@@ -30,10 +30,13 @@ def paint_ball(ball, surface):
     Draws a ball onto the given PyGame surface.
     ball : the ball to draw => Ball instance
     surface : the destination surface => PyGame.Surface
+    (returns sequence of Rect, or an empty sequence)
     """
+    s = []
     if ball.is_visible():
-        pygame.draw.circle(surface, ball.get_bg_color(), ball.get_center(),
-                           int(ball.get_diameter() / 2))
+        r = pygame.draw.circle(surface, ball.get_bg_color(), ball.get_center(),
+                               int(ball.get_diameter() / 2))
+        s.append(r)
         ball_center = ball.get_center()
         txt_width, txt_height = ball.get_txt_font().size(ball.get_operation().
                                                          get_text())
@@ -41,7 +44,9 @@ def paint_ball(ball, surface):
                         int(ball_center[1] - txt_height / 2))
         txt_surface = ball.get_txt_font().render(
             ball.get_operation().get_text(), 1, ball.get_txt_color())
-        surface.blit(txt_surface, txt_position)
+        r = surface.blit(txt_surface, txt_position)
+        s.append(r)
+    return s
 
 
 def paint_time_bar(time_bar, surface):
@@ -49,20 +54,25 @@ def paint_time_bar(time_bar, surface):
     Draws a time bar onto the given PyGame surface.
     time_bar : the time bar => TimeBar
     surface : the destination surface => PyGame.Surface
+    (returns sequence of Rect)
     """
+    s = []
     edge = time_bar.get_edge()
     dead_rect = (edge[0], edge[1],
                  time_bar.get_width(), time_bar.get_height())
-    pygame.draw.rect(surface, time_bar.get_dead_color(), dead_rect)
+    r = pygame.draw.rect(surface, time_bar.get_dead_color(), dead_rect)
+    s.append(r)
     try:
         value = time_bar.get_value()
         max_value = time_bar.get_max_value()
         active_rect = (edge[0], edge[1],
                        int(time_bar.get_width() * value / max_value),
                        time_bar.get_height())
-        pygame.draw.rect(surface, time_bar.get_active_color(), active_rect)
+        r = pygame.draw.rect(surface, time_bar.get_active_color(), active_rect)
     except NameError:
-        pygame.draw.rect(surface, time_bar.get_active_color(), dead_rect)
+        r = pygame.draw.rect(surface, time_bar.get_active_color(), dead_rect)
+    s.append(r)
+    return s
 
 
 def paint_result_bar(result_bar, surface):
@@ -70,20 +80,25 @@ def paint_result_bar(result_bar, surface):
     Draws a result bar onto a given PyGame surface.
     result_bar : the result bar => ResultBar
     surface : the destination surface => PyGame.Surface
+    (returns sequence of Rect)
     """
+    s = []
     edge = result_bar.get_edge()
     rect = (edge[0], edge[1],
             result_bar.get_width(), result_bar.get_height())
-    pygame.draw.rect(surface, result_bar.get_background(), rect)
+    r = pygame.draw.rect(surface, result_bar.get_background(), rect)
+    s.append(r)
     try:
         text = result_bar.get_header() + str(result_bar.get_result())
     except NameError:
         text = result_bar.get_header()
     text_surface = result_bar.get_text_font().render(
         text, 1, result_bar.get_foreground())
-    surface.blit(text_surface,
-                 (edge[0] + result_bar.get_insets(),
-                  edge[1] + result_bar.get_insets()))
+    r = surface.blit(text_surface,
+                     (edge[0] + result_bar.get_insets(),
+                      edge[1] + result_bar.get_insets()))
+    s.append(r)
+    return s
 
 
 def paint_results(game_area, balls_list, surface):
@@ -92,7 +107,9 @@ def paint_results(game_area, balls_list, surface):
     game_area : area of the balls => tuple of 4 integer
     balls_list : list of balls => list of Ball
     surface : the destination surface => PyGame.Surface
+    (returns sequence of Rect)
     """
+    s = []
     font = pygame.font.Font(None, 40)
     #font = PangoFont(family='Helvetica', size=16)
     LINE_HEIGHT = font.size("0123456789")[1]
@@ -100,14 +117,17 @@ def paint_results(game_area, balls_list, surface):
     ball_index = 0
     BLACK = (0, 0, 0)
     for ball in balls_list:
-        pygame.draw.circle(surface, ball.get_bg_color(),
+        r = pygame.draw.circle(surface, ball.get_bg_color(),
                           (game_area[0] + CIRCLES_RADIUS,
                            game_area[
                                1] + ball_index * LINE_HEIGHT + CIRCLES_RADIUS),
                            CIRCLES_RADIUS)
+        s.append(r)
         txt = ball.get_operation().get_text() + " = " + str(ball.get_operation().
                                                             get_result())
         txt_surface = font.render(txt, 1, BLACK)
-        surface.blit(txt_surface,
+        r = surface.blit(txt_surface,
                      (game_area[0] + 40, game_area[1] + ball_index * LINE_HEIGHT))
+        s.append(r)
         ball_index += 1
+    return s
diff --git a/main_game.py b/main_game.py
index 110ebf3..54e696d 100644
--- a/main_game.py
+++ b/main_game.py
@@ -50,6 +50,7 @@ class Game:
         Constructor.
         """
         self._initialized = False
+        self.s = self.p = []
 
     def _lazy_init(self):
         """
@@ -60,7 +61,7 @@ class Game:
             return
         pygame.init()
         self._LEFT_BUTTON = 1
-        self._FPS = 40
+        self._FPS = 10
         self._MENU_LEVELS_RECTS_Y_GAP = 30
         self._MENU_LEVELS_RECTS_WIDTH = 345
         self._MENU_LEVELS_RECTS_HEIGHT = 60
@@ -167,6 +168,19 @@ class Game:
         y_good = point[1] >= rect[1] and point[1] <= rect[1] + rect[3]
         return x_good and y_good
 
+    def _update(self):
+        """
+        Update the screen rectangles that have been changed by drawing
+        actions since the last update (self.s), including rectangles
+        that were cleared the previous update (self.p), then clear the
+        current rectangles (self.s) in preparation for the next cycle.
+        """
+        pygame.display.update(self.s + self.p)
+        self.p = self.s
+        for r in self.s:
+            self._screen.fill(self._GAME_BACKGROUND, r)
+        self.s = []
+
     def _play_game(self, time_seconds, operations_config):
         """ The main game routine
             time_seconds : time limit in seconds => integer
@@ -174,20 +188,8 @@ class Game:
             => list of
             OperationConfig.
         """
-        # Shows loading screen
         self._screen.fill(self._MENU_BACKGROUND)
-        loading_txt = _("Loading...")
-        loading_txt_surface = self._end_font.render(
-            loading_txt,
-            True,
-            self._BLUE
-        )
-        txt_size = self._end_font.size(loading_txt)
-        self._screen.blit(loading_txt_surface, (
-            (self._size[0] - txt_size[0]) / 2,
-            (self._size[1] - txt_size[1]) / 2,
-        ))
-        pygame.display.update()
+        self._update()
 
         game_state = GameState.NORMAL
 
@@ -220,16 +222,14 @@ class Game:
         pygame.time.set_timer(USEREVENT + 2, 1000)
 
         while True:
-            pygame.display.update()
-            self._screen.fill(self._GAME_BACKGROUND)
-            paint_result_bar(result_bar, self._screen)
-            paint_time_bar(time_bar, self._screen)
+            while Gtk.events_pending():
+                Gtk.main_iteration()
+            self._update()
+            self.s += paint_result_bar(result_bar, self._screen)
+            self.s += paint_time_bar(time_bar, self._screen)
             if game_state == GameState.NORMAL:
                 for ball in the_balls:
-                    paint_ball(ball, self._screen)
-
-                while Gtk.events_pending():
-                    Gtk.main_iteration()
+                    self.s += paint_ball(ball, self._screen)
 
                 for event in pygame.event.get():
                     if event.type == QUIT:
@@ -253,12 +253,12 @@ class Game:
                                         game_state = GameState.WON
                                 else:
                                     game_state = GameState.LOST
-                self._clock.tick(self._FPS)
                 for ball in the_balls:
                     ball.move()
                 balls_collision.manage_colliding_balls(the_balls)
+                self._clock.tick(self._FPS)
             else:
-                paint_results(balls_area, the_balls, self._screen)
+                self.s += paint_results(balls_area, the_balls, self._screen)
                 # Blinks the status text.
                 if show_status:
                     if game_state == GameState.WON:
@@ -268,10 +268,7 @@ class Game:
                     end_txt_surface = self._end_font.render(end_txt, True,
                                                             self._BLUE,
                                                             self._RED)
-                    self._screen.blit(end_txt_surface, self._END_TXT_POS)
-
-                while Gtk.events_pending():
-                    Gtk.main_iteration()
+                    self.s.append(self._screen.blit(end_txt_surface, self._END_TXT_POS))
 
                 for event in pygame.event.get():
                     if event.type == QUIT:
@@ -282,31 +279,36 @@ class Game:
                     elif event.type == MOUSEBUTTONUP:
                         if event.button == self._LEFT_BUTTON:
                             return
+                self._clock.tick(5)
 
     def show_menu(self):
         """
         Manages the main menu.
         """
         self._lazy_init()
+        self.s = []
+        self.s.append(self._screen.fill(self._MENU_BACKGROUND))
+        self._update()
         while True:
-            self._screen.fill(self._MENU_BACKGROUND)
+            while Gtk.events_pending():
+                Gtk.main_iteration()
+            self._update()
             for box_index in range(len(self._levels)):
                 box_value = self._levels_rect[box_index]
-                pygame.draw.rect(
+                s = pygame.draw.rect(
                     self._screen, self._MENU_LEVELS_RECTS_BG_COLOR,
                     box_value)
+                self.s.append(s)
                 txt = _("Level ") + str(box_index + 1)
                 txt_surface = self._menu_font.render(txt, True,
                                                      self._MENU_LEVELS_RECTS_TXT_COLOR)
-                self._screen.blit(txt_surface,
+                s = self._screen.blit(txt_surface,
                                   (self._levels_rect[box_index][0] +
                                    self._MENU_LEVELS_RECTS_TXT_OFFSET[0],
                                    self._levels_rect[box_index][1] +
                                    self._MENU_LEVELS_RECTS_TXT_OFFSET[1]
                                    ))
-            pygame.display.update()
-            while Gtk.events_pending():
-                Gtk.main_iteration()
+                self.s.append(s)
 
             for event in pygame.event.get():
                 if event.type == QUIT:
@@ -324,3 +326,13 @@ class Game:
                             self._play_game(
                                 30,
                                 self._levels[selected_level_index])
+            self._clock.tick(5)
+
+def main():
+    pygame.init()
+    pygame.display.set_mode((0, 0), pygame.RESIZABLE)
+    game = Game() 
+    game.show_menu()
+
+if __name__ == '__main__':
+    main()