Pygame Object Oriented Tutorial – Complete Guide

Ready to delve into the exciting world of Pygame Object-Oriented Programming (OOP)? In this comprehensive guide, we’re going to break down the barriers and make Pygame OOP accessible – even fun – for everyone, no matter your skill level.

What is Pygame Object-Oriented Programming?

In essence, Pygame is a set of Python modules designed to allow you to create video games. When we talk about Object-Oriented Programming in Pygame, we’re actually referring to a programming paradigm which is focused on creating “objects”, each with their own properties and methods.

What is Pygame OOP for?

The beauty of Pygame OOP lies in how it makes complex programming tasks simpler and more manageable. By organizing code into objects, you create reusable components which can interact with each other – a must have in the world of game development!

Why should you learn Pygame OOP?

Learning Pygame OOP expands your toolset as a game developer significantly. It will allow you to keep your code clean, modular, and easy to debug. Plus, knowing OOP is a transferrable skill – many key programming languages (like Java and C++) heavily use this concept, offering great future learning opportunities.

FREE COURSES AT ZENVA

LEARN GAME DEVELOPMENT, PYTHON AND MORE

ACCESS FOR FREE

AVAILABLE FOR A LIMITED TIME ONLY

Setting up Pygame

Before we dive into creating objects, we first need to ensure that Pygame is correctly installed and set up. If you haven’t already, you can install it through pip:

pip install pygame

Upon successful installation, it’s time to import Pygame and initialize it in our project:

import pygame
pygame.init()

Creating a Simple Game Loop

In Pygame, all games require a main game loop. This is what continuously runs and updates the game state:

import pygame
pygame.init()

game_running = True
while game_running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_running = False

pygame.quit()

This code will create a basic game loop that will run until we tell it to quit.

Creating an Object

In OOP, the key feature is the creation and interaction of objects. Let’s create our first object, which will be a basic player character:

class Player():
    def __init__(self):
        self.position = [0, 0]
        self.speed = 10

player_one = Player()

We’ve just created a Player class and initialized a player_one instance of it.

Moving an Object

Our Player can’t do much at the moment. Let’s give him the ability to move. We’ll do this by adding a method to our Player class that modifies the position:

class Player():
    def __init__(self):
      self.position = [0, 0]
      self.speed = 10

    def move_right(self):
      self.position[0] += self.speed

player_one = Player()
player_one.move_right()

We’ve now added a method that allows our player to move right on the screen its own speed.

Event Handling with Pygame

Now that we have a moving object, let’s see how we can utilize Pygame’s event handling to give our object the ability to react to player input:

class Player():
    def __init__(self):
        self.position = [0, 0]
        self.speed = 10

    def move_right(self):
        self.position[0] += self.speed

    def move_left(self):
        self.position[0] -= self.speed

player_one = Player()

while game_running:
    for event in pygame.event.get():
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_RIGHT:
                player_one.move_right()
            if event.key == pygame.K_LEFT:
                player_one.move_left()

With this, we now have a player that can move right and left based on our keyboard input!

Collision Detection

Another common feature in games is collision detection. Let’s create another object for our player to collide with and create a simple bounding box collision detection method to see if the two objects overlap:

class Player():
    # player class here

class Obstacle():
    def __init__(self):
        self.position = [100, 100]
        self.size = [20, 20]

player_one = Player()
obstacle = Obstacle()

def check_collision(player, obstacle):
  if (player.position[0]  obstacle.position[0] and
      player.position[1]  obstacle.position[1]):
    return True
  return False

With this function, we’ll be able to tell when player_one collides with an obstacle.

Rendering Objects

Our objects are colliding, but we’re not seeing anything yet. The final step to making our game functional is to render our objects onto the screen. We can do this using Pygame’s Surface drawing methods.

screen = pygame.display.set_mode((800, 600))

while game_running:
    # Event handling here

    # Draw player
    pygame.draw.rect(screen, (255,255,255), (player_one.position[0], player_one.position[1], player_one.size[0], player_one.size[1]))
    # Draw obstacle
    pygame.draw.rect(screen, (255,0,0), (obstacle.position[0], obstacle.position[1], obstacle.size[0], obstacle.size[1]))

    # Swap buffers
    pygame.display.flip()

Now you’ll be able to see your objects and their movements! With these techniques, you’re well on your way to creating complex Pygame projects using Object-Oriented Programming!

Adding More Features

Our current game definitely works, but there’s still a lot more we can add to further practice Pygame OOP!
Let’s continue to add more features, making our game more enticing to play.

Moving in All Directions

We’ve enabled our player object to move right and left, but what about up and down? Similarly to how we did it before, we just need to add a couple more methods to our Player class in order to allow moving up and down:

class Player():
    # existing code

    def move_up(self):
        self.position[1] -= self.speed

    def move_down(self):
        self.position[1] += self.speed

Now in our event handling, we’ll allow the player to use the up and down keys to move the player in those directions too:

while game_running:
    for event in pygame.event.get():
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_RIGHT:
                player_one.move_right()
            if event.key == pygame.K_LEFT:
                player_one.move_left()
            if event.key == pygame.K_UP:
                player_one.move_up()
            if event.key == pygame.K_DOWN:
                player_one.move_down()

Our player can now move freely in all directions!

Adding a Display Score

Let’s introduce a scoring system into our game. In Pygame, we can use the Pygame Font module to render text onto the screen, indicating the player’s current score:

font = pygame.font.Font(None, 36)
score = 0

while game_running:
    # game loop here

    text = font.render("Score: " + str(score), 1, (10, 10, 10))
    screen.blit(text, (10,10))

However, our score never changes. Let’s update our collision function to add points to our score whenever the player successfully avoids an obstacle:

def check_collision(player, obstacle):
    # existing code here

    if not collision:
        score += 1

Now, every frame without a collision adds a point to our score, visible on the screen!

Game Over Condition

Finally, it doesn’t make much sense for our player to continue moving around after colliding with an obstacle. Let’s end the game when a collision is detected:

if check_collision(player_one, obstacle):
    game_running = False

With this, our Pygame Object-Oriented Programming journey has taken us from basic class creation all the way to a fully functioning (if simple) game! Enjoy playing with these foundations and seeing what other exciting features you can add.

Where to Go Next?

Now that you’ve taken your first steps into Pygame Object-Oriented Programming, the world of game development is your oyster! But where should you go next to continue honing your programming skills and dive deeper into game creation?

At Zenva, we believe in making learning accessible and fun. We invite you to explore further with our Python Mini-Degree. It offers an exciting blend of courses designed to enhance your understanding of Python programming. From algorithms to object-oriented programming, and even extending to game and app development, this comprehensive bundle offers a multi-faceted learning journey. You’ll get hands-on experience with popular libraries and frameworks such as Pygame, Tkinter, and Kivy as you create games, medical diagnosis bots, and real-world apps.

Moreover, make sure to check out our broader collection of Python courses to explore a wide range of lessons and topics. With our flexible courses, you can learn at your own pace and on your own time. Get started today and enter the rewarding realm of Python programming and game development!

Conclusion

Stepping into the world of Pygame Object-Oriented Programming has hopefully given you a taste of what’s possible. Through creating interactive objects, incorporating event handling, detecting collisions, implementing scoring systems, and game-ending conditions, you’ve established your game development basics. The critical thing to remember is that learning to program, like game development, is a journey. You’ve taken crucial first steps, but there’s always more to explore!

We at Zenva would be thrilled to join you on this exciting journey. Our Python Mini-Degree will supercharge your skillset, providing hands-on courses that dive deeper into Python and its vast applications, including Pygame. Made by the industry’s leading professionals, our courses guide you through the tech world one step at a time, letting you learn at your own pace. Let’s unlock your full potential and make your coding dreams a reality today!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

FREE COURSES

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.

ACCESS FOR FREE