使用Pygame，有没有更快的方法来绘制数百个小方块？

Question

I'm attempting to make a tile based game, not done anything like this before so I'm learning as I go along. However, I've got a big problem with speed, and I was wondering if anyone had any solutions/advice. I tried to separate recalculating bits and the actual drawing, though as you can only move the camera currently, it's got to do both at once, and it's very noticeable how slow it runs if you have a small tilesize and large resolution.

I thought an idea would be to split it into chunks, so you calculate an x*x area, and instead of checking each tile if it's within the screen bounds, you only check the group of tiles, then somehow cache it the first time it's drawn so you then end up drawing a single image from memory. However I didn't find anything on that when googling it.

As to the drawing part, it runs to the effect of:

for tile in tile_dict:
    pygame.draw.rect(precalculated stuff)

With the same tilesize as the image below, at 720p it runs at 100fps, and at 1080p it runs at 75fps. This is with literally nothing but drawing squares. Each block is a slightly different colour, so I can't just draw a bigger square. I know not to redraw every frame by the way.

As to the recalculation part, it's a bit longer but still quite easy to understand. I calculate which coordinates would be at the edge of the screen, and use that to build a list of all on screen tiles. I then delete any tiles that are outside of this area, move the cooordinate to the new location if the tile has moved on screen, and calculate any tiles that have just appeared. This runs at about 90fps at 720p, or 45fps at 1080p, which is really not good.

def recalculate(self):
    overflow = 2
    x_min = self.cam.x_int + 1 - overflow
    y_min = self.cam.y_int + 1 - overflow
    x_max = self.cam.x_int + int(self.WIDTH / self.tilesize) + overflow
    y_max = self.cam.y_int + int(self.HEIGHT / self.tilesize) + overflow


    self.screen_coordinates = [(x, y) 
                               for x in range(x_min, x_max) 
                               for y in range(y_min, y_max)]


    #Delete the keys that have gone off screen
    del_keys = []
    for key in self.screen_block_data:
        if not x_min < key[0] < x_max or not y_min < key[1] < y_max:
            del_keys.append(key)
    for key in del_keys:
        del self.screen_block_data[key]


    #Rebuild the new list of blocks
    block_data_copy = self.screen_block_data.copy()
    for coordinate in self.screen_coordinates:

        tile_origin = ((coordinate[0] - self.cam.x_int) - self.cam.x_float, 
                       (coordinate[1] - self.cam.y_int) - self.cam.y_float)
        tile_location = tuple(i * self.tilesize for i in tile_origin)

        #Update existing point with new location
        if coordinate in self.screen_block_data:
            self.screen_block_data[coordinate][2] = tile_location
            continue

        block_type = get_tile(coordinate)

        #Generate new point info
        block_hash = quick_hash(*coordinate, offset=self.noise_level)

        #Get colour
        if coordinate in self.game_data.BLOCK_TAG:
            main_colour = CYAN   #in the future, mix this with the main colour
        else:
            main_colour = TILECOLOURS[block_type]
        block_colour = [min(255, max(0, c + block_hash)) for c in main_colour]
        self.screen_block_data[coordinate] = [block_type, 
                                              block_colour, 
                                              tile_location]

I realised in what I wrote above, I probably could cache the info for a 10x10 area or something to cut down on what needs to be done when moving the camera, but that still doesn't get around the problem with drawing.

I can upload the full code if anyone wants to try stuff with it (it's split over a few files so probably easier to not paste everything here), but here's a screenshot of how it looks currently for a bit of reference:

Answer 1

To increase the speed of drawing the small squares, you can draw them onto non-screen surface (any pygame surface that will be big enough to hold all the squares) and then blit this surface on the screen with correct coordinates. This way you won't need to check if any squares are outside the screen and it will be only necessary to provide inverted camera (viewpoint) coordinates (If camera position is [50,20] then you should blit the surface with tiles onto [-50,-20]).