How to develop a game in Python

The most adaptable language is Python, which is used in nearly every industry, including game development, web development, machine learning, artificial intelligence, and GUI applications.

The game is developed using the pygame package, which is a built-in feature of Python. With a rudimentary understanding of Python programming, we may create visually appealing games with appropriate animation, sound effects, and music by utilizing the pygame module.

A cross-platform library called Pygame is used to create video games. It has sound libraries and computer visuals to provide the player with a typical gaming experience.

Pete Shinners is developing it to take the place of PySDL.

Prerequisites for Pygame

We need to comprehend the Python programming language in order to learn Pygame.

Installing Pygame

To install Pygame, open a command-line terminal and enter the following command.

We can also install it through IDE. For further installation guide, visit our complete pygame tutorial (https://www.javatpoint.com/pygame). Here you will find all the essential pygame explanations.

Simple Pygame Example

Here is the following example of creating a simple pygame window.

import pygame  
  
pygame.init()  
screen = pygame.display.set_mode((400,500))  
done = False  
  
while not done:  
    for event in pygame.event.get():  
        if event.type == pygame.QUIT:  
            done = True  
    pygame.display.flip()  

Output:

Explanation:

The code supplied opens a 400x500 pixel Pygame window and starts a loop that watches for events all the time. The loop changes the 'done' variable to True, which ends the loop and ends the program if a QUIT event is detected (usually when the user quits the window). Updates the display and makes sure that any changes are shown on the screen thanks to the 'pygame.display.flip()' method. To put it briefly, the code generates a small Pygame window that stays active until the user dismisses it, exhibiting a basic program structure that is event-driven.

All graphics will draw in the pygame window.

Let's understand the basic syntax of the above program.

import pygame: It is the module that gives us access to all of Pygame's functions.
init(): It is employed to initialize each of the pygame's necessary modules.
display.set_mode((width, height)): It's employed to adjust the window's size. It will give back the item on the surface. The graphical actions are carried out through the surface object.
event.get(): The result is an empty event queue. If we don't call it, the operating system will perceive the game as unresponsive, and the window messages will begin to accumulate.
QUIT: When we click the cross button in the window's corner, it is utilized to dismiss the event.
display.flip(): Any updates to the game are reflected in it. We must contact the display whenever we make any changes.flip() is a function.

Any form may be drawn on the Pygame surface, including beautiful fonts and pictures. Numerous built-in methods in Pygame allow you to draw geometric shapes on the screen. These forms represent the first steps in creating a game.

Let's examine the following illustration of a form being drawn on a screen.

Example -

import pygame  
from math import pi  
pygame.init()  
# size variable is using for set screen size  
size = [400, 300]  
screen = pygame.display.set_mode(size)  
pygame.display.set_caption("Example program to draw geometry")  
# done variable is using as flag   
done = False  
clock = pygame.time.Clock()  
while not done:  
    # clock.tick() limits the while loop to a max of 10 times per second.  
        clock.tick(10)  
  
    for event in pygame.event.get():  # User did something  
        if event.type == pygame.QUIT:  # If user clicked on close symbol   
            done = True  # done variable that we are complete, so we exit this loop  
  
    # All drawing code occurs after the for loop and but  
    # inside the main while done==False loop.  
  
    # Clear the default screen background and set the white screen background  
    screen.fill((0, 0, 0))  
  
    # Draw on the screen a green line which is 5 pixels wide.  
    pygame.draw.line(screen, (0, 255, 0), [0, 0], [50, 30], 5)  
    # Draw on the screen a green line which is 5 pixels wide.  
    pygame.draw.lines(screen, (0, 0, 0), False, [[0, 80], [50, 90], [200, 80], [220, 30]], 5)  
  
    # Draw a rectangle outline  
    pygame.draw.rect(screen, (0, 0, 0), [75, 10, 50, 20], 2)  
  
    # Draw a solid rectangle  
    pygame.draw.rect(screen, (0, 0, 0), [150, 10, 50, 20])  
  
    # This draw an ellipse outline, using a rectangle as the outside boundaries  
    pygame.draw.ellipse(screen, (255, 0, 0), [225, 10, 50, 20], 2)  
  
    # This draw a solid ellipse, using a rectangle as the outside boundaries  
    pygame.draw.ellipse(screen, (255, 0, 0), [300, 10, 50, 20])  
  
    # Draw a triangle using the polygon function  
    pygame.draw.polygon(screen, (0, 0, 0), [[100, 100], [0, 200], [200, 200]], 5)  
  
    # This draw a circle  
    pygame.draw.circle(screen, (0, 0, 255), [60, 250], 40)  
  
    # This draw an arc  
    pygame.draw.arc(screen, (0, 0, 0), [210, 75, 150, 125], 0, pi / 2, 2)  
  
    # This function must write after all the other drawing commands.  
    pygame.display.flip()  
  
# Quite the execution when clicking on close  
pygame.quit()  

Output:

Explanation:

The given Python program creates a graphical window with different geometric shapes drawn in it by using the Pygame package. The program creates a 400x300 pixel Pygame window, and it then starts a loop that watches for events all the time, making sure the window stays open until the user quits it. It clears the screen at the beginning of this loop and then uses Pygame's drawing routines to create a variety of forms with varying colors and line widths. These shapes include lines, polygons, ellipses, circles, and arcs. Every form has its proper coordinates and properties defined. Lastly, 'pygame.display.flip()' is used to refresh the display. The program terminates pygame upon window closure.

The application serves as an example of Pygame's drawing capabilities' adaptability and variety and provides a framework for developing interactive graphical applications. Developers may create a vast range of visual components inside Pygame's graphical environment by adjusting parameters like coordinates, colors, and line widths. This allows for the construction of interactive multimedia applications, games, and simulations.

Example - Developing Snake Game Using Pygame

Program -

# Snake Tutorial Using Pygame 

import math
import random
import pygame
import tkinter as tk
from tkinter import messagebox


class cube(object):
    rows = 20
    w = 500

    def __init__(self, start, dirnx=1, dirny=0, color=(255, 0, 0)):
        self.pos = start
        self.dirnx = 1
        self.dirny = 0
        self.color = color

    def move(self, dirnx, dirny):
        self.dirnx = dirnx
        self.dirny = dirny
        self.pos = (self.pos[0] + self.dirnx, self.pos[1] + self.dirny)

    def draw(self, surface, eyes=False):
        dis = self.w // self.rows
        i = self.pos[0]
        j = self.pos[1]

        pygame.draw.rect(surface, self.color, (i * dis + 1, j * dis + 1, dis - 2, dis - 2))
        if eyes:
            centre = dis // 2
            radius = 3
            circleMiddle = (i * dis + centre - radius, j * dis + 8)
            circleMiddle2 = (i * dis + dis - radius * 2, j * dis + 8)
            pygame.draw.circle(surface, (0, 0, 0), circleMiddle, radius)
            pygame.draw.circle(surface, (0, 0, 0), circleMiddle2, radius)

# This class is defined for snake design and its movement
class snake(object):
    body = []
    turns = {}

    def __init__(self, color, pos):
        self.color = color
        self.head = cube(pos)
        self.body.append(self.head)
        self.dirnx = 0
        self.dirny = 1

    def move(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()

            keys = pygame.key.get_pressed()
            # It will manage the keys movement for the snake
            for key in keys:
                if keys[pygame.K_LEFT]:
                    self.dirnx = -1
                    self.dirny = 0
                    self.turns[self.head.pos[:]] = [self.dirnx, self.dirny]

                elif keys[pygame.K_RIGHT]:
                    self.dirnx = 1
                    self.dirny = 0
                    self.turns[self.head.pos[:]] = [self.dirnx, self.dirny]

                elif keys[pygame.K_UP]:
                    self.dirnx = 0
                    self.dirny = -1
                    self.turns[self.head.pos[:]] = [self.dirnx, self.dirny]

                elif keys[pygame.K_DOWN]:
                    self.dirnx = 0
                    self.dirny = 1
                    self.turns[self.head.pos[:]] = [self.dirnx, self.dirny]
        # Snake when hit the boundary wall
        for i, c in enumerate(self.body):
            p = c.pos[:]
            if p in self.turns:
                turn = self.turns[p]
                c.move(turn[0], turn[1])
                if i == len(self.body) - 1:
                    self.turns.pop(p)
            else:
                if c.dirnx == -1 and c.pos[0] <= 0:
                    c.pos = (c.rows - 1, c.pos[1])
                elif c.dirnx == 1 and c.pos[0] >= c.rows - 1:
                    c.pos = (0, c.pos[1])
                elif c.dirny == 1 and c.pos[1] >= c.rows - 1:
                    c.pos = (c.pos[0], 0)
                elif c.dirny == -1 and c.pos[1] <= 0:
                    c.pos = (c.pos[0], c.rows - 1)
                else:
                    c.move(c.dirnx, c.dirny)

    def reset(self, pos):
        self.head = cube(pos)
        self.body = []
        self.body.append(self.head)
        self.turns = {}
        self.dirnx = 0
        self.dirny = 1
# It will add the new cube in snake tail after every successful score
    def addCube(self):
        tail = self.body[-1]
        dx, dy = tail.dirnx, tail.dirny

        if dx == 1 and dy == 0:
            self.body.append(cube((tail.pos[0] - 1, tail.pos[1])))
        elif dx == -1 and dy == 0:
            self.body.append(cube((tail.pos[0] + 1, tail.pos[1])))
        elif dx == 0 and dy == 1:
            self.body.append(cube((tail.pos[0], tail.pos[1] - 1)))
        elif dx == 0 and dy == -1:
            self.body.append(cube((tail.pos[0], tail.pos[1] + 1)))

        self.body[-1].dirnx = dx
        self.body[-1].dirny = dy

    def draw(self, surface):
        for i, c in enumerate(self.body):
            if i == 0:
                c.draw(surface, True)
            else:
                c.draw(surface)


def drawGrid(w, rows, surface):
    sizeBtwn = w // rows

    x = 0
    y = 0
    for l in range(rows):
        x = x + sizeBtwn
        y = y + sizeBtwn
        # draw grid line
        pygame.draw.line(surface, (255, 255, 255), (x, 0), (x, w))
        pygame.draw.line(surface, (255, 255, 255), (0, y), (w, y))

# This class define for draw game surface
def redrawWindow(surface):
    global rows, width, s, snack
    # This is used to grid surface
    surface.fill((0, 0, 0))
    s.draw(surface)
    snack.draw(surface)
    drawGrid(width, rows, surface)
    pygame.display.update()


def randomSnack(rows, item):
    positions = item.body

    while True:
        x = random.randrange(rows)
        y = random.randrange(rows)
        if len(list(filter(lambda z: z.pos == (x, y), positions))) > 0:
            continue
        else:
            break

    return (x, y)

# Using Tkinter function to display message
def message_box(subject, content):
    root = tk.Tk()
    root.attributes("-topmost", True)
    root.withdraw()
    messagebox.showinfo(subject, content)
    try:
        root.destroy()
    except:
        pass

# main() function
def main():
    global width, rows, s, snack
    width = 500
    rows = 20
    win = pygame.display.set_mode((width, width))
    s = snake((255, 0, 0), (10, 10))
    snack = cube(randomSnack(rows, s), color=(0, 255, 0))
    flag = True

    clock = pygame.time.Clock()

    while flag:
        pygame.time.delay(50)
        clock.tick(10)
        s.move()
        if s.body[0].pos == snack.pos:
            s.addCube()
            snack = cube(randomSnack(rows, s), color=(0, 255, 0))

        for x in range(len(s.body)):
            if s.body[x].pos in list(map(lambda z: z.pos, s.body[x + 1:])):
                print('Score: \n', len(s.body))
                message_box('You Lost!\n', 'Play again...\n')
                s.reset((10, 10))
                break

        redrawWindow(win)

    pass


main()

Output:

If the snake touches itself then it will terminate the game and display the following message.

To resume, simply click the OK button. The Pycharm terminal displays our score (we used the Pycharm IDE, but you may use any Python IDE).

Explanation:

The provided Python script uses the Pygame package to create a straightforward Snake game. It establishes classes for both the Snake and the separate cubes that make up its body. Pygame is used to set up the game window, which features a grid structure and a moving snake. After eating a "snack" cube, the snake lengthens, and if it runs into itself or the boundary walls, the game is over.

In order to manage the snake's direction, generate snacks at random points on the grid, detect collisions between the snake's head and body, update the game state, and redraw the game window, the game logic must handle user input. To control game interactions and visual updates, the script makes use of Pygame's event handling and drawing methods. It also has a basic message box feature that uses Tkinter to show the player messages, such as when they lose a game. Overall, the script shows key ideas in Pygame game programming and offers a rudimentary rendition of the vintage Snake game.

Next TopicHow to install Tkinter in Python

← prev next →

How to develop a game in Python

Prerequisites for Pygame

Installing Pygame

Simple Pygame Example

Example - Developing Snake Game Using Pygame

Latest Courses

Contact info

Follow us

Tutorials

Interview Questions

Online Compiler

Python

AI, ML and Data Science

Java

B.Tech and MCA

Web Technology

Software Testing

Technical Interview

Java Interview

Web Interview

Database Interview

Company Interviews

Python Tutorial

Python OOPs

Python MySQL

Python MongoDB

Python SQLite

Python Questions

Plotly

Python Tkinter (GUI)

Python Web Blocker

Python MCQ

Related Tutorials

Python Programs

Python String functions

Python Functions

How to develop a game in Python

Prerequisites for Pygame

Installing Pygame

Simple Pygame Example

Example - Developing Snake Game Using Pygame

Latest Courses

Contact info

Follow us

Tutorials

Interview Questions

Online Compiler