In this tutorial you will learn how to build the game snake.  The game is an arcade game and it has very simple logic, which is why it is an ideal example to demonstrate how to build games with Pygame.

The player is represented as snake, which grows if it eats an apple. The goal of the game is to eat as many apples as possible without colliding into yourself.  This is very easy in the early phase of the game but is increasingly more difficult as the length of the snake grows.

Related courses:

• Practice Python with interactive exercises
• Practice Python with interactive exercises

Getting started: Basic structure and event handling. We define a class Player which holds the players position on the screen and the speed by which it moves. In addition we define the actions a Player instance can do (movements):

class Player:
    x = 10
    y = 10
    speed = 1
def moveRight(self):
        self.x = self.x + self.speed
def moveLeft(self):
        self.x = self.x - self.speed
def moveUp(self):
        self.y = self.y - self.speed
def moveDown(self):
        self.y = self.y + self.speed

A player object can be created and variables can be modified using the movement methods. We link those methods to the events. In Pygame we can get non-blocking keyboard input using this code:

pygame.event.pump()
 keys = pygame.key.get_pressed() 
            
 if (keys[K_RIGHT]):
    print "Right arrow pressed."

The complete code gives us the ability to move the player across the screen:

from pygame.locals import *
import pygame
class Player:
    x = 10
    y = 10
    speed = 1
def moveRight(self):
        self.x = self.x + self.speed
def moveLeft(self):
        self.x = self.x - self.speed
def moveUp(self):
        self.y = self.y - self.speed
def moveDown(self):
        self.y = self.y + self.speed
class App:
windowWidth = 800
    windowHeight = 600
    player = 0
def __init__(self):
        self._running = True
        self._display_surf = None
        self._image_surf = None
        self.player = Player()
def on_init(self):
        pygame.init()
        self._display_surf = pygame.display.set_mode((self.windowWidth,self.windowHeight), pygame.HWSURFACE)
        
        pygame.display.set_caption('Pygame pythonspot.com example')
        self._running = True
        self._image_surf = pygame.image.load("pygame.png").convert()
 
    def on_event(self, event):
        if event.type == QUIT:
            self._running = False
def on_loop(self):
        pass
    
    def on_render(self):
        self._display_surf.fill((0,0,0))
        self._display_surf.blit(self._image_surf,(self.player.x,self.player.y))
        pygame.display.flip()
 
    def on_cleanup(self):
        pygame.quit()
 
    def on_execute(self):
        if self.on_init() == False:
            self._running = False
 
        while( self._running ):
            pygame.event.pump()
            keys = pygame.key.get_pressed() 
            
            if (keys[K_RIGHT]):
                self.player.moveRight()
if (keys[K_LEFT]):
                self.player.moveLeft()
if (keys[K_UP]):
                self.player.moveUp()
if (keys[K_DOWN]):
                self.player.moveDown()
if (keys[K_ESCAPE]):
                self._running = False
self.on_loop()
            self.on_render()
        self.on_cleanup()
 
if __name__ == "__main__" :
    theApp = App()
    theApp.on_execute()

You can now move the block around the screen with the arrow keys.

pygame example. Move the block around the screen

Building the player (snake) The player controls a snake which has an initial length. This snake is always moving and changes the direction it moves when pressing an arrow key. To do so, update the player class:

class Player:
    x = 0
    y = 0
    speed = 32
    direction = 0
def update(self):
        if self.direction == 0:
            self.x = self.x + self.speed
        if self.direction == 1:
            self.x = self.x - self.speed
        if self.direction == 2:
            self.y = self.y - self.speed
        if self.direction == 3:
            self.y = self.y + self.speed
def moveRight(self):
        self.direction = 0
def moveLeft(self):
        self.direction = 1
def moveUp(self):
        self.direction = 2
def moveDown(self):
        self.direction = 3

and don't forget to add a delay to the game loop.

import time
...
time.sleep (100.0 / 1000.0);

This starts to act more as a snake, but it does not have a base length yet. We keep track of the snakes old positions and move the head of the snake.  We also moved the drawing method into the snake. Copy the code and you will have a moving snake:

from pygame.locals import *
import pygame
import time
class Player:
    x = []
    y = []
    step = 44
    direction = 0
    length = 3
 
    updateCountMax = 2
    updateCount = 0
def __init__(self, length):
       self.length = length
       for i in range(0,length):
           self.x.append(0)
           self.y.append(0)
def update(self):
self.updateCount = self.updateCount + 1
        if self.updateCount > self.updateCountMax:
# update previous positions
            for i in range(self.length-1,0,-1):
                print "self.x[" + str(i) + "] = self.x[" + str(i-1) + "]"
                self.x[i] = self.x[i-1]
                self.y[i] = self.y[i-1]
# update position of head of snake
            if self.direction == 0:
                self.x[0] = self.x[0] + self.step
            if self.direction == 1:
                self.x[0] = self.x[0] - self.step
            if self.direction == 2:
                self.y[0] = self.y[0] - self.step
            if self.direction == 3:
                self.y[0] = self.y[0] + self.step
self.updateCount = 0
def moveRight(self):
        self.direction = 0
def moveLeft(self):
        self.direction = 1
def moveUp(self):
        self.direction = 2
def moveDown(self):
        self.direction = 3
def draw(self, surface, image):
        for i in range(0,self.length):
            surface.blit(image,(self.x[i],self.y[i]))
class App:
windowWidth = 800
    windowHeight = 600
    player = 0
def __init__(self):
        self._running = True
        self._display_surf = None
        self._image_surf = None
        self.player = Player(10)
def on_init(self):
        pygame.init()
        self._display_surf = pygame.display.set_mode((self.windowWidth,self.windowHeight), pygame.HWSURFACE)
        
        pygame.display.set_caption('Pygame pythonspot.com example')
        self._running = True
        self._image_surf = pygame.image.load("pygame.png").convert()
 
    def on_event(self, event):
        if event.type == QUIT:
            self._running = False
def on_loop(self):
        self.player.update()
        pass
    
    def on_render(self):
        self._display_surf.fill((0,0,0))
        self.player.draw(self._display_surf, self._image_surf)
        pygame.display.flip()
 
    def on_cleanup(self):
        pygame.quit()
 
    def on_execute(self):
        if self.on_init() == False:
            self._running = False
 
        while( self._running ):
            pygame.event.pump()
            keys = pygame.key.get_pressed() 
            
            if (keys[K_RIGHT]):
                self.player.moveRight()
if (keys[K_LEFT]):
                self.player.moveLeft()
if (keys[K_UP]):
                self.player.moveUp()
if (keys[K_DOWN]):
                self.player.moveDown()
if (keys[K_ESCAPE]):
                self._running = False
            self.on_loop()
            self.on_render()
time.sleep (50.0 / 1000.0);
        self.on_cleanup()
 
if __name__ == "__main__" :
    theApp = App()
    theApp.on_execute()

Result:

python snake

Game logic The snake game has some rules:

• If the snake eats an apple, the apple moves to a new position.
• If the snake eats an apple, the snakes length grows.
• If a snake collapses with itself, game over.

We start by creating a new class that enables us to create apples:

class Apple:
    x = 0
    y = 0
    step = 44
def __init__(self,x,y):
        self.x = x * self.step
        self.y = y * self.step
def draw(self, surface, image):
        surface.blit(image,(self.x, self.y))

For simplicity sake, we display the apples as green cubes.  We have this basic code, but it does not do a lot more than moving the snake and showing the apple:

from pygame.locals import *
import pygame
import time
class Apple:
    x = 0
    y = 0
    step = 44
def __init__(self,x,y):
        self.x = x * self.step
        self.y = y * self.step
def draw(self, surface, image):
        surface.blit(image,(self.x, self.y))
class Player:
    x = []
    y = []
    step = 44
    direction = 0
    length = 3
 
    updateCountMax = 2
    updateCount = 0
def __init__(self, length):
       self.length = length
       for i in range(0,length):
           self.x.append(0)
           self.y.append(0)
def update(self):
self.updateCount = self.updateCount + 1
        if self.updateCount > self.updateCountMax:
# update previous positions
            for i in range(self.length-1,0,-1):
                print "self.x[" + str(i) + "] = self.x[" + str(i-1) + "]"
                self.x[i] = self.x[i-1]
                self.y[i] = self.y[i-1]
# update position of head of snake
            if self.direction == 0:
                self.x[0] = self.x[0] + self.step
            if self.direction == 1:
                self.x[0] = self.x[0] - self.step
            if self.direction == 2:
                self.y[0] = self.y[0] - self.step
            if self.direction == 3:
                self.y[0] = self.y[0] + self.step
self.updateCount = 0
def moveRight(self):
        self.direction = 0
def moveLeft(self):
        self.direction = 1
def moveUp(self):
        self.direction = 2
def moveDown(self):
        self.direction = 3
def draw(self, surface, image):
        for i in range(0,self.length):
            surface.blit(image,(self.x[i],self.y[i]))
class App:
windowWidth = 800
    windowHeight = 600
    player = 0
    apple = 0
def __init__(self):
        self._running = True
        self._display_surf = None
        self._image_surf = None
        self._apple_surf = None
        self.player = Player(10) 
        self.apple = Apple(5,5)
def on_init(self):
        pygame.init()
        self._display_surf = pygame.display.set_mode((self.windowWidth,self.windowHeight), pygame.HWSURFACE)
        
        pygame.display.set_caption('Pygame pythonspot.com example')
        self._running = True
        self._image_surf = pygame.image.load("pygame.png").convert()
        self._apple_surf = pygame.image.load("apple.png").convert()
def on_event(self, event):
        if event.type == QUIT:
            self._running = False
def on_loop(self):
        self.player.update()
        pass
    
    def on_render(self):
        self._display_surf.fill((0,0,0))
        self.player.draw(self._display_surf, self._image_surf)
        self.apple.draw(self._display_surf, self._apple_surf)
        pygame.display.flip()
 
    def on_cleanup(self):
        pygame.quit()
 
    def on_execute(self):
        if self.on_init() == False:
            self._running = False
 
        while( self._running ):
            pygame.event.pump()
            keys = pygame.key.get_pressed() 
            
            if (keys[K_RIGHT]):
                self.player.moveRight()
if (keys[K_LEFT]):
                self.player.moveLeft()
if (keys[K_UP]):
                self.player.moveUp()
if (keys[K_DOWN]):
                self.player.moveDown()
if (keys[K_ESCAPE]):
                self._running = False
self.on_loop()
            self.on_render()
time.sleep (50.0 / 1000.0);
        self.on_cleanup()
 
if __name__ == "__main__" :
    theApp = App()
    theApp.on_execute()

We have thus to add the game logic. To know if the snakes position matches the apples position, we have to do collision detection. This simply means veryfing that the cordinate of the snake are intersecting with the coordinates of the apple.  We create a new method to do that:

def isCollision(self,x1,y1,x2,y2,bsize):
        if x1 >= x2 and x1 <= x2 + bsize:
            if y1 >= y2 and y1 <= y2 + bsize:
                return True
        return False

It will return True if the coordinates (x1,y1) are intersection with (x2,y2) given its block size bsize. We call this method to determine if the snake collides with the apple. We need to check this for the entire snake and not only for the head, because we do not want the new position of the apple to be somewhere on the snake. We use the same isCollision method to determine if the snake collides with itself (= lose game).

Full source:

from pygame.locals import *
from random import randint
import pygame
import time
 
class Apple:
    x = 0
    y = 0
    step = 44
 
    def __init__(self,x,y):
        self.x = x * self.step
        self.y = y * self.step
 
    def draw(self, surface, image):
        surface.blit(image,(self.x, self.y)) 
 
 
class Player:
    x = [0]
    y = [0]
    step = 44
    direction = 0
    length = 3
 
    updateCountMax = 2
    updateCount = 0
 
    def __init__(self, length):
       self.length = length
       for i in range(0,2000):
           self.x.append(-100)
           self.y.append(-100)
 
       # initial positions, no collision.
       self.x[1] = 1*44
       self.x[2] = 2*44
 
    def update(self):
 
        self.updateCount = self.updateCount + 1
        if self.updateCount > self.updateCountMax:
 
            # update previous positions
            for i in range(self.length-1,0,-1):
                self.x[i] = self.x[i-1]
                self.y[i] = self.y[i-1]
 
            # update position of head of snake
            if self.direction == 0:
                self.x[0] = self.x[0] + self.step
            if self.direction == 1:
                self.x[0] = self.x[0] - self.step
            if self.direction == 2:
                self.y[0] = self.y[0] - self.step
            if self.direction == 3:
                self.y[0] = self.y[0] + self.step
 
            self.updateCount = 0
 
 
    def moveRight(self):
        self.direction = 0
 
    def moveLeft(self):
        self.direction = 1
 
    def moveUp(self):
        self.direction = 2
 
    def moveDown(self):
        self.direction = 3 
 
    def draw(self, surface, image):
        for i in range(0,self.length):
            surface.blit(image,(self.x[i],self.y[i])) 
 
class Game:
    def isCollision(self,x1,y1,x2,y2,bsize):
        if x1 >= x2 and x1 <= x2 + bsize:
            if y1 >= y2 and y1 <= y2 + bsize:
                return True
        return False
 
class App:
 
    windowWidth = 800
    windowHeight = 600
    player = 0
    apple = 0
 
    def __init__(self):
        self._running = True
        self._display_surf = None
        self._image_surf = None
        self._apple_surf = None
        self.game = Game()
        self.player = Player(3) 
        self.apple = Apple(5,5)
 
    def on_init(self):
        pygame.init()
        self._display_surf = pygame.display.set_mode((self.windowWidth,self.windowHeight), pygame.HWSURFACE)
 
        pygame.display.set_caption('Pygame pythonspot.com example')
        self._running = True
        self._image_surf = pygame.image.load("block.jpg").convert()
        self._apple_surf = pygame.image.load("block.jpg").convert()
 
    def on_event(self, event):
        if event.type == QUIT:
            self._running = False
 
    def on_loop(self):
        self.player.update()
 
        # does snake eat apple?
        for i in range(0,self.player.length):
            if self.game.isCollision(self.apple.x,self.apple.y,self.player.x[i], self.player.y[i],44):
                self.apple.x = randint(2,9) * 44
                self.apple.y = randint(2,9) * 44
                self.player.length = self.player.length + 1
 
 
        # does snake collide with itself?
        for i in range(2,self.player.length):
            if self.game.isCollision(self.player.x[0],self.player.y[0],self.player.x[i], self.player.y[i],40):
                print("You lose! Collision: ")
                print("x[0] (" + str(self.player.x[0]) + "," + str(self.player.y[0]) + ")")
                print("x[" + str(i) + "] (" + str(self.player.x[i]) + "," + str(self.player.y[i]) + ")")
                exit(0)
 
        pass
 
    def on_render(self):
        self._display_surf.fill((0,0,0))
        self.player.draw(self._display_surf, self._image_surf)
        self.apple.draw(self._display_surf, self._apple_surf)
        pygame.display.flip()
 
    def on_cleanup(self):
        pygame.quit()
 
    def on_execute(self):
        if self.on_init() == False:
            self._running = False
 
        while( self._running ):
            pygame.event.pump()
            keys = pygame.key.get_pressed() 
 
            if (keys[K_RIGHT]):
                self.player.moveRight()
 
            if (keys[K_LEFT]):
                self.player.moveLeft()
 
            if (keys[K_UP]):
                self.player.moveUp()
 
            if (keys[K_DOWN]):
                self.player.moveDown()
 
            if (keys[K_ESCAPE]):
                self._running = False
 
            self.on_loop()
            self.on_render()
 
            time.sleep (50.0 / 1000.0);
        self.on_cleanup()
 
if __name__ == "__main__" :
    theApp = App()
    theApp.on_execute()

Conclusion:

You learned how to create the game snake in Python along with concepts such as collision detection, image loading and event handling. Many things could be added to this little toy game but this serves as a very simple example. :-)

Next tutorial