From f57ab3583a29bf35d5517d0cec1e10eafeb43bc4 Mon Sep 17 00:00:00 2001
From: Mateu Batle <mateu.batle@collabora.co.uk>
Date: Mon, 15 Nov 2010 02:28:27 +0000
Subject: optimized rendering function

---
(limited to 'game1')

diff --git a/game1/collectgame.py b/game1/collectgame.py
index 7adc99f..d729614 100755
--- a/game1/collectgame.py
+++ b/game1/collectgame.py
@@ -72,7 +72,7 @@ class CollectGame(usmpgames.ApplicationState):
     def render(self,  ms):
         offsety = self.player.getOffsetY()
         if not self.track.endOfTrack(offsety) :
-            self.track.draw(self.screen(), offsety)
+            self.track.drawFast(self.screen(), offsety)
             self.player.draw(self.screen())
         self.score.draw(self.screen())
         
diff --git a/game1/tracktmx.py b/game1/tracktmx.py
index 30c666d..d99bade 100755
--- a/game1/tracktmx.py
+++ b/game1/tracktmx.py
@@ -32,6 +32,9 @@ class Track():
         self.load()
         self.num_odd = 0
         self.num_even = 0
+        self.cached_surface = None
+        self.cached_offset = 0
+        self.cached_height = 0
 
     def load(self, filename = "./tracks/track1.tmx"):
         self.world_map = TileMapParser().parse_decode(filename)
@@ -41,18 +44,53 @@ class Track():
     def endOfTrack(self, offset = 0):
         return (offset + 200 >= self.world_map.height * self.world_map.tileheight)
 
-    def draw(self,  screen,  offset = 0): 
+    def drawFast(self, screen, offset = 0):
+        if self.cached_surface is None:
+            self.cached_surface = pygame.Surface(screen_size)
+            self.cached_offset = 0
+            self.cached_height = 0
+        else:
+            # scroll offset difference      
+            self.cached_surface.scroll(0, -int(offset - self.cached_offset))
+            self.cached_height -= int(offset - self.cached_offset)
+            if self.cached_height < 0:
+                self.cached_height = 0
+                
+        # draw new tiles
+        height = screen_size[1] - self.cached_height
+        #print "offset = ", offset + self.cached_height, "height=", height, "horizon_y=", self.cached_height
+        self.draw(self.cached_surface, offset + self.cached_height, height, self.cached_height)
+        self.cached_offset = offset
+        self.cached_height = screen_size[1]
+        
+        # draw whole thing to screen
+        screen.blit(self.cached_surface, (0,0))
+
+    def draw(self,  screen,  offset = 0, height = 0, horizon_y = 0): 
         # cam_offset is for scrolling
         cam_offset_x = 0
-        cam_offset_y = -offset
+        cam_offset_y = offset
         screen_width = screen_size[0]
-        screen_height = screen_size[1]
+        if height == 0:
+            screen_height = screen_size[1]
+        else:
+            screen_height = height
+        #horizon_y = 0
         # draw the map
         for layer in self.world_map.layers[:]:
             if layer.visible:
                 idx = 0
+                numtilex = 0
+                num = 0
                 # loop over all tiles
-                for ypos in xrange(0, layer.height):
+                starty = int ( offset / self.world_map.tileheight )
+                numtilesy = int (height + self.world_map.tileheight - 1) / self.world_map.tileheight
+                #print "starty = ", starty, "numtilesy= ", numtilesy                
+                
+                totalrect_sc = pygame.Rect((0, horizon_y), (screen_width, height))
+                
+                #for ypos in xrange(0, layer.height):
+                for ypos in xrange(starty, starty + numtilesy):
                     for xpos in xrange(0, layer.width):
                         # add offset in number of tiles
                         x = (xpos + layer.x) * self.world_map.tilewidth
@@ -62,11 +100,15 @@ class Track():
                         material = self.world_map.indexed_tiles_tileset[img_idx]
                         idx += 1
                         if img_idx:
+                            
                             # get the actual image and its offset
                             offx, offy, screen_img = self.world_map.indexed_tiles[img_idx]
+                            tile_sc = pygame.Rect((x - cam_offset_x + offx, y - cam_offset_y + horizon_y + offy), (self.world_map.tilewidth, self.world_map.tileheight))
                             # only draw the tiles that are relly visible (speed up)
-                            if x >= cam_offset_x - 3 * self.world_map.tilewidth and x + cam_offset_x <= screen_width + self.world_map.tilewidth\
-                               and y >= cam_offset_y - 3 * self.world_map.tileheight and y + cam_offset_y <= screen_height + 3 * self.world_map.tileheight:
+                            #print "y=", y - cam_offset_y + horizon_y + offy, "miny=", horizon_y, "maxy", horizon_y + screen_height
+                            if totalrect_sc.colliderect(tile_sc):
+                            #if x >= cam_offset_x - 3 * self.world_map.tilewidth and x + cam_offset_x <= screen_width + self.world_map.tilewidth\
+                            #   and y >= cam_offset_y - 3 * self.world_map.tileheight and y + cam_offset_y <= screen_height + 3 * self.world_map.tileheight:
                                 """
                                 if screen_img.get_alpha():
                                     screen_img = screen_img.convert_alpha()
@@ -80,10 +122,11 @@ class Track():
                                 screen_img = screen_img.convert_alpha()
                                 """
                                 # draw image at right position using its offset
-                                screen.blit(screen_img, (x + cam_offset_x + offx, y + cam_offset_y + offy + horizon_y))
+                                screen.blit(screen_img, (x - cam_offset_x + offx, y - cam_offset_y + offy + horizon_y))
+                                #num = num + 1
                                 if material == "goals":
                                     surface = self.getTextSurface(xpos, ypos, img_idx)
-                                    screen.blit(surface, (x + cam_offset_x + offx + 10, y + cam_offset_y + offy + horizon_y + 10))
+                                    screen.blit(surface, (x - cam_offset_x + offx + 10, y - cam_offset_y + offy + horizon_y + 10))
                                     
         """
         # map objects
--
cgit v0.9.1