logo

Snake with Pygame

snake GameIn 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:

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.

<caption id=”attachment_589” align=”alignnone” width=”400”]pygame 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 &gt; 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:

<caption id=”attachment_594” align=”alignnone” width=”592”]python snake 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