Pygame laggy на MacBook Pro

Question

Я пытаюсь сделать видеоигру с Pygame на моем MBP 2013 (i5, 4go RAM, intel iris 1536mo), и любой образец, который я могу найти в Интернете, безумно лагги. Однако если запустить эти игры с более старой макинтош (2011) - но с выделенной графической картой (??) - я могу играть в игры без FPS выдает

Вот один из образца (от http://programarcadegames.com/index.php?lang=en&chapter=example_code_platformer)

Я пытался change pygame.display.flip() с pygame.display.update() без успеха, и clock.tick(30) с pygame.timer.wait() со случайными результатами ...

Любая идея, что может решить мою проблему?

""" 
Sample Python/Pygame Programs 
Simpson College Computer Science 
http://programarcadegames.com/ 
http://simpson.edu/computer-science/ 

From: 
http://programarcadegames.com/python_examples/f.php?file=platform_scroller.py 

Explanation video: http://youtu.be/QplXBw_NK5Y 

Part of a series: 
http://programarcadegames.com/python_examples/f.php?file=move_with_walls_example.py 
http://programarcadegames.com/python_examples/f.php?file=maze_runner.py 
http://programarcadegames.com/python_examples/f.php?file=platform_jumper.py 
http://programarcadegames.com/python_examples/f.php?file=platform_scroller.py 
http://programarcadegames.com/python_examples/f.php?file=platform_moving.py 
http://programarcadegames.com/python_examples/sprite_sheets/ 

""" 

import pygame 
import time 

# Global constants 

# Colors 
BLACK = ( 0, 0, 0) 
WHITE = (255, 255, 255) 
BLUE  = ( 0, 0, 255) 
RED  = (255, 0, 0) 
GREEN = ( 0, 255, 0) 

# Screen dimensions 
SCREEN_WIDTH = 800 
SCREEN_HEIGHT = 600 

class Player(pygame.sprite.Sprite): 
    """ 
    This class represents the bar at the bottom that the player controls. 
    """ 

    # -- Attributes 
    # Set speed vector of player 
    change_x = 0 
    change_y = 0 

    # List of sprites we can bump against 
    level = None 

    # -- Methods 
    def __init__(self): 
     """ Constructor function """ 

     # Call the parent's constructor 
     super().__init__() 

     # Create an image of the block, and fill it with a color. 
     # This could also be an image loaded from the disk. 
     width = 40 
     height = 60 
     self.image = pygame.Surface([width, height]) 
     self.image.fill(RED) 

     # Set a referance to the image rect. 
     self.rect = self.image.get_rect() 

    def update(self): 
     """ Move the player. """ 
     # Gravity 
     self.calc_grav() 

     # Move left/right 
     self.rect.x += self.change_x 

     # See if we hit anything 
     block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) 
     for block in block_hit_list: 
      # If we are moving right, 
      # set our right side to the left side of the item we hit 
      if self.change_x > 0: 
       self.rect.right = block.rect.left 
      elif self.change_x < 0: 
       # Otherwise if we are moving left, do the opposite. 
       self.rect.left = block.rect.right 

     # Move up/down 
     self.rect.y += self.change_y 

     # Check and see if we hit anything 
     block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) 
     for block in block_hit_list: 

      # Reset our position based on the top/bottom of the object. 
      if self.change_y > 0: 
       self.rect.bottom = block.rect.top 
      elif self.change_y < 0: 
       self.rect.top = block.rect.bottom 

      # Stop our vertical movement 
      self.change_y = 0 

    def calc_grav(self): 
     """ Calculate effect of gravity. """ 
     if self.change_y == 0: 
      self.change_y = 1 
     else: 
      self.change_y += .35 

     # See if we are on the ground. 
     if self.rect.y >= SCREEN_HEIGHT - self.rect.height and self.change_y >= 0: 
      self.change_y = 0 
      self.rect.y = SCREEN_HEIGHT - self.rect.height 

    def jump(self): 
     """ Called when user hits 'jump' button. """ 

     # move down a bit and see if there is a platform below us. 
     # Move down 2 pixels because it doesn't work well if we only move down 1 
     # when working with a platform moving down. 
     self.rect.y += 2 
     platform_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) 
     self.rect.y -= 2 

     # If it is ok to jump, set our speed upwards 
     if len(platform_hit_list) > 0 or self.rect.bottom >= SCREEN_HEIGHT: 
      self.change_y = -10 

    # Player-controlled movement: 
    def go_left(self): 
     """ Called when the user hits the left arrow. """ 
     self.change_x = -6 

    def go_right(self): 
     """ Called when the user hits the right arrow. """ 
     self.change_x = 6 

    def stop(self): 
     """ Called when the user lets off the keyboard. """ 
     self.change_x = 0 

class Platform(pygame.sprite.Sprite): 
    """ Platform the user can jump on """ 

    def __init__(self, width, height): 
     """ Platform constructor. Assumes constructed with user passing in 
      an array of 5 numbers like what's defined at the top of this code. 
      """ 
     super().__init__() 

     self.image = pygame.Surface([width, height]) 
     self.image.fill(GREEN) 

     self.rect = self.image.get_rect() 

class Level(): 
    """ This is a generic super-class used to define a level. 
     Create a child class for each level with level-specific 
     info. """ 

    # Lists of sprites used in all levels. Add or remove 
    # lists as needed for your game. 
    platform_list = None 
    enemy_list = None 

    # How far this world has been scrolled left/right 
    world_shift = 0 

    def __init__(self, player): 
     """ Constructor. Pass in a handle to player. Needed for when moving 
      platforms collide with the player. """ 
     self.platform_list = pygame.sprite.Group() 
     self.enemy_list = pygame.sprite.Group() 
     self.player = player 

    # Update everythign on this level 
    def update(self): 
     """ Update everything in this level.""" 
     self.platform_list.update() 
     self.enemy_list.update() 

    def draw(self, screen): 
     """ Draw everything on this level. """ 

     # Draw the background 
     screen.fill(BLUE) 

     # Draw all the sprite lists that we have 
     self.platform_list.draw(screen) 
     self.enemy_list.draw(screen) 

    def shift_world(self, shift_x): 
     """ When the user moves left/right and we need to scroll everything: """ 

     # Keep track of the shift amount 
     self.world_shift += shift_x 

     # Go through all the sprite lists and shift 
     for platform in self.platform_list: 
      platform.rect.x += shift_x 

     for enemy in self.enemy_list: 
      enemy.rect.x += shift_x 

# Create platforms for the level 
class Level_01(Level): 
    """ Definition for level 1. """ 

    def __init__(self, player): 
     """ Create level 1. """ 

     # Call the parent constructor 
     Level.__init__(self, player) 

     self.level_limit = -1000 

     # Array with width, height, x, and y of platform 
     level = [[210, 70, 500, 500], 
       [210, 70, 800, 400], 
       [210, 70, 1000, 500], 
       [210, 70, 1120, 280], 
       ] 


     # Go through the array above and add platforms 
     for platform in level: 
      block = Platform(platform[0], platform[1]) 
      block.rect.x = platform[2] 
      block.rect.y = platform[3] 
      block.player = self.player 
      self.platform_list.add(block) 

# Create platforms for the level 
class Level_02(Level): 
    """ Definition for level 2. """ 

    def __init__(self, player): 
     """ Create level 1. """ 

     # Call the parent constructor 
     Level.__init__(self, player) 

     self.level_limit = -1000 

     # Array with type of platform, and x, y location of the platform. 
     level = [[210, 30, 450, 570], 
       [210, 30, 850, 420], 
       [210, 30, 1000, 520], 
       [210, 30, 1120, 280], 
       ] 


     # Go through the array above and add platforms 
     for platform in level: 
      block = Platform(platform[0], platform[1]) 
      block.rect.x = platform[2] 
      block.rect.y = platform[3] 
      block.player = self.player 
      self.platform_list.add(block) 

def main(): 
    """ Main Program """ 
    pygame.init() 

    # Set the height and width of the screen 
    size = [SCREEN_WIDTH, SCREEN_HEIGHT] 
    screen = pygame.display.set_mode(size) 

    pygame.display.set_caption("Side-scrolling Platformer") 

    # Create the player 
    player = Player() 

    # Create all the levels 
    level_list = [] 
    level_list.append(Level_01(player)) 
    level_list.append(Level_02(player)) 

    # Set the current level 
    current_level_no = 0 
    current_level = level_list[current_level_no] 

    active_sprite_list = pygame.sprite.Group() 
    player.level = current_level 

    player.rect.x = 340 
    player.rect.y = SCREEN_HEIGHT - player.rect.height 
    active_sprite_list.add(player) 

    #Loop until the user clicks the close button. 
    done = False 

    # Used to manage how fast the screen updates 
    clock = pygame.time.Clock() 

    # -------- Main Program Loop ----------- 
    tick = 0 
    current_milli_time = lambda: int(round(time.time() * 1000)) 
    mtime = current_milli_time() 
    while not done: 
     for event in pygame.event.get(): # User did something 
      if event.type == pygame.QUIT: # If user clicked close 
       done = True # Flag that we are done so we exit this loop 

      if event.type == pygame.KEYDOWN: 
       if event.key == pygame.K_LEFT: 
        player.go_left() 
       if event.key == pygame.K_RIGHT: 
        player.go_right() 
       if event.key == pygame.K_UP: 
        player.jump() 

      if event.type == pygame.KEYUP: 
       if event.key == pygame.K_LEFT and player.change_x < 0: 
        player.stop() 
       if event.key == pygame.K_RIGHT and player.change_x > 0: 
        player.stop() 

     # Update the player. 
     active_sprite_list.update() 

     # Update items in the level 
     current_level.update() 

     # If the player gets near the right side, shift the world left (-x) 
     if player.rect.right >= 500: 
      diff = player.rect.right - 500 
      player.rect.right = 500 
      current_level.shift_world(-diff) 

     # If the player gets near the left side, shift the world right (+x) 
     if player.rect.left <= 120: 
      diff = 120 - player.rect.left 
      player.rect.left = 120 
      current_level.shift_world(diff) 

     # If the player gets to the end of the level, go to the next level 
     current_position = player.rect.x + current_level.world_shift 
     if current_position < current_level.level_limit: 
      player.rect.x = 120 
      if current_level_no < len(level_list)-1: 
       current_level_no += 1 
       current_level = level_list[current_level_no] 
       player.level = current_level 

     # ALL CODE TO DRAW SHOULD GO BELOW THIS COMMENT 
     current_level.draw(screen) 
     active_sprite_list.draw(screen) 

     # ALL CODE TO DRAW SHOULD GO ABOVE THIS COMMENT 

     if tick %30 == 0: 
      print (current_milli_time() - mtime) 
      mtime = current_milli_time() 
     tick+=1 
     # Limit to 30 frames per second 
     clock.tick(30) 

     # Go ahead and update the screen with what we've drawn. 
     pygame.display.flip() 

    # Be IDLE friendly. If you forget this line, the program will 'hang' 
    # on exit. 
    pygame.quit() 

if __name__ == "__main__": 
    main() 

Answer 1

производительность игры зависит от факторов:

1. CPU usage required for the game 
2. Graphics card and their drivers 
3. Random Access Memory aka RAM 

Поскольку программы Pygame не что-промышленные, там не должно быть слишком много, использование процессора от вашей игры. Что касается видеокарты, вы должны быть настроены, я имею в виду, что это MacBook Pro. Вы, наверное, получили графику Intel HD. Наконец, ваша оперативная память, вероятно, является источником отставания.

ОЗУ хранит используемые данные для текущего сеанса пользователя. Если у вас есть только 2 ГБ памяти, и у вас есть тысячи активов и переменных в вашей игре, вы наверняка будете использовать хороший объем памяти. Вы можете:

1. Limit other processes or programs. 
2. Compress game assets and variables. 
3. Upgrade the amount of RAM. 

Прибегать только к последнему, если вы в отчаянии.