Index

1. PyGame Sprites

• an excellent turorial exists for PyGame sprites here.
• these notes are derived from this tutorial and the examples extended
  • initially without object orientation and later to include orientation with the previous lecture on PyGame and the bouncing ball example
• sprites are quite complicated
  • in my experience this is due to their close association with object orientation
  • you can use sprites without OO
  • for a small number of sprites this is easy enough and the code is smaller than its OO counterpart (and much simpler)
  • for any reasonable number of sprites >= 3 then should use OO as the reduction in code probably offsets the OO complication

2. When to use Sprites in PyGame

• when you have:
  • many instances of an object on the screen at a time
  • some objects that you need to track closely (e.g. collision detection)
    • Sprites have a self.rect attribute, which can be passed to the function colliderect
  • objects that need to update themselves rather than waiting for events to happen passively
  • a Sprite’s update() method, with a time argument, makes it easy to deal with a dynamic environment
• if you absolutely, positively need speed, and know exactly what you’re doing
  • sprites and sprite groups are fast, but if you’re careful, you can be faster
• do consider this until you have profiled your existing code
  • and have removed the more obvious time sinks

3. When not to use Sprites

• when your:
  • objects don’t share much (if any) code
    • and if you rarely have more than one copy of each instantiated at a time
  • loop is event-based, and things never move by themselves
• simple user interfaces are often easier to do with surfaces than with sprites

4. Creating a simple sprite

• #!/usr/bin/python
  
  import pygame
  from pygame.locals import KEYDOWN
  
  width  = 320
  height = 240
  size   = [width, height]
  pygame.init()
  screen = pygame.display.set_mode(size)
  background = pygame.Surface(screen.get_size())
  
  b = pygame.sprite.Sprite() # create sprite
  b.image = pygame.image.load("ball.png").convert() # load ball image
  b.rect = b.image.get_rect() # use image extent values
  b.rect.topleft = [0, 0] # put the ball in the top left corner
  screen.blit(b.image, b.rect)
  
  
  pygame.display.update()
  while pygame.event.poll().type != KEYDOWN:
      pygame.time.delay(100)

5. Sprite in PyGame

• is an object that contains both:
  • an image (a Surface)
  • and a location at which to draw that image (a Rect)
• term sprite is actually a holdover from older display systems that did such manipulations directly in hardware
  • Commodore 64, Commodore Amiga used this technique in early 1980s to early 1990s
  • other manufactures did exactly the same, Atari etc
• Sprites work well in object-oriented languages like Python
  • you have a standard sprite interface pygame.sprite.Sprite , and extend those classes as specific sprites
• see the BallSprite class in the example later on
• Sprites have two important instance variables
  • self.image and self.rect
  • self.image is a Surface, which is the current image that will be displayed. self.rect is the location at which this image will be displayed when the sprite is drawn to the screen
• Sprites also have one important instance method, self.update .

6. Creating a simple sprite using an extra Class

• #!/usr/bin/python
  
  import pygame
  from pygame.locals import KEYDOWN
  
  class BallSprite(pygame.sprite.Sprite):
      image = None
  
      def __init__(self, location):
          pygame.sprite.Sprite.__init__(self)
  
          if BallSprite.image is None:
              # This is the first time this class has been
              # instantiated. So, load the image for this and
              # all subsequence instances.
              BallSprite.image = pygame.image.load("ball.png")
          self.image = BallSprite.image
  
  
          # Make our top-left corner the passed-in location.
          self.rect = self.image.get_rect()
          self.rect.topleft = location

• pygame.init()
  screen = pygame.display.set_mode([320, 320])
  b = BallSprite([0, 0]) # put the ball in the top left corner
  screen.blit(b.image, b.rect)
  pygame.display.update()
  while pygame.event.poll().type != KEYDOWN:
      pygame.time.delay(10)

7. Bouncing ball using spites and no user defined classes

• #!/usr/bin/python
  
  import pygame
  from pygame.locals import KEYDOWN
  
  width  = 320
  height = 240
  size   = [width, height]
  ydir = 1
  xdir = 1
  xpos = 0
  ypos = 0
  pygame.init()
  screen = pygame.display.set_mode(size)
  background = pygame.Surface(screen.get_size())
  
  
  b = pygame.sprite.Sprite() # create sprite
  b.image = pygame.image.load("ball.png").convert()  # load image
  b.rect = b.image.get_rect() # use image extent values
  b.rect.topleft = [xpos, ypos] # put the ball in the top left corner
  screen.blit(b.image, b.rect)
  slow = 0

• def gravity(y):
      global height
      return 0
      return (((height+height/20) * 3) / y)
  
  pygame.display.update()
  while pygame.event.poll().type != KEYDOWN:
      pygame.time.delay(gravity(ypos))
      # If we’re at the top or bottom of the screen,
      # switch directions.
  
  
      if b.rect.bottom>=height:
          ydir = -1
      elif ypos == 0:
          ydir = 1
      if xpos == 0:
          xdir = 1
      elif b.rect.right>=width:
          xdir = -1

•     if slow:
          screen.fill([0, 0, 0]) # blank the screen
      else:
          rectlist = [screen.blit(background, b.rect)]
  
      # Move our position up or down by one pixel
      xpos += xdir
      ypos += ydir
      b.rect.topleft = [xpos, ypos]
  
  
      if slow:
          screen.blit(b.image, b.rect)
          pygame.display.update()
      else:
          rectlist += [screen.blit(b.image, b.rect)]
          pygame.display.update(rectlist)

• #!/usr/bin/python
  
  import pygame
  from pygame.locals import KEYDOWN
  
  class BallSprite(pygame.sprite.Sprite):
      image = None
  
      def __init__(self, initial_position):
          pygame.sprite.Sprite.__init__(self)
          if BallSprite.image is None:
              BallSprite.image = pygame.image.load("ball.png")
          self.image = BallSprite.image
  
  
          self.rect = self.image.get_rect()
          self.rect.topleft = initial_position
          self.going_down = True # Start going downwards
          self.next_update_time = 0 # update() hasn’t been called yet.

•     def update(self, current_time, bottom):
          # Update every 10 milliseconds = 1/100th of a second.
          if self.next_update_time < current_time:
  
              # If we’re at the top or bottom of the screen, switch directions.
              if self.rect.bottom == bottom - 1: self.going_down = False
              elif self.rect.top == 0: self.going_down = True
  
              # Move our position up or down by one pixel
              if self.going_down: self.rect.top += 1
              else: self.rect.top -= 1
  
  
              self.next_update_time = current_time + 10

• pygame.init()
  boxes = []
  for location in [[0, 0],
                   [60, 60],
                   [120, 120]]:
      boxes.append(BallSprite(location))
  
  screen = pygame.display.set_mode([150, 150])
  while pygame.event.poll().type != KEYDOWN:
      screen.fill([0, 0, 0]) # blank the screen.
  
  
      time = pygame.time.get_ticks()
      for b in boxes:
          b.update(time, 150)
          screen.blit(b.image, b.rect)
      pygame.display.update()

• it is worth noting that the OO solution uses processor resources efficiently
  

8. Tutorial

• modify the last example so that the balls also move on the x axis as well
• now add the gravity effect

Index

This document was produced using groff-1.19.