Bullet Game is our near-end stage pygame 2d game framework example. We've already done at least 6 or 7 other games using pygame. So this will document the patterns we have learned.

We began by “just writing” a game, then the second part was refactoring the game. I wanted to make refactoring it's own project. What are the goals of this refactoring?

• Refactoring
  • Encapsulation
  • Light Commentary (code commentary) ex. IN and OUT for functions.

The primary goal is encapsulation. So, we're going to break up the old main into several new classes.

The first part of this is the use of pygame framework. We'll describe the additions here.

• Box Sprites – the kind of sprites first used in this game.

Here is the code we added, starting with main.py:

from Window import *
from Game import *

def main():
    window = Window()
    window.setCaption("Bullet Game")
    window.setSize(Screen.WIDTH, Screen.HEIGHT)
    window.setFont("assets/ps2p.ttf", 32)

    game = Game(window)
    game.start()

if __name__ == "__main__":
    main()

class Screen:
    WIDTH = 800
    HEIGHT = 600
    FPS = 60

    MARGIN = 96
    GAMETOP = MARGIN
    GAMEBOT = HEIGHT - MARGIN

import pygame
import random
import pickle

from Screen import *
from Window import *
from Bullet import *
from Color import *
from Screen import *
from Zombie import *
from SpaceShip import *
from Sound import *
from Player import *
from Constants import *
from Level import *
from Star import *


class Game:
    def __init__(self, window):
        self.window = window
        self.sound = Sound()

        # Initialize Game World Data
        # The Player & Level
        self.player = Player()
        self.player.hiscore = self.load_hiscore("score.txt")

        self.level = Level(1, self.player)

        # Bullet list
        self.bullets = pygame.sprite.Group()

        # Zombies list
        self.zombies = pygame.sprite.Group()
        self.spaceships = pygame.sprite.Group()

        # 30 random stars.
        self.stars = []
        for n in range(30):
            x = random.randint(0, Screen.WIDTH)
            y = random.randint(0, Screen.HEIGHT)
            self.stars.append((x, y))

        # All member variables are now globals:
        # Try commenting it out to see what happens!
        globals().update(self.__dict__)

    #################################
    ##          Main Loop          ##
    #################################

    def start(self):

        # Clock for controlling the frame rate
        clock = pygame.time.Clock()

        # Main game loop
        running = True
        frame_counter = 0

        ##################
        # GAME LOOP ORDER OF EVENTS:
        ##################
        sound.play("start")
        # pygame.mixer.init()
        # pygame.mixer.music.load('assets/sound/waveafterwave.mp3')
        # pygame.mixer.music.play()

        # Start of Game Loop
        time_start = time.time() * 1000
        LEVEL_DELAY = 3000
        while running:
            time_clock = (time.time() * 1000) - time_start
            frame_counter += 1
            if frame_counter > 60:
                frame_counter = 1

            ########################
            # 1. EVENT HANDLING
            ########################
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                    quit_game()
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_z:
                        self.create_spaceship()
                    if event.key == pygame.K_ESCAPE:
                        self.quit_game()
                    if event.key == pygame.K_q:
                        self.quit_game()

                    if event.key == pygame.K_w:
                        x = self.player.rect.x + self.player.SIZE / 2
                        y = self.player.rect.y + self.player.SIZE / 2
                        self.create_bullet(x, y, 0, -1)

            # Continuous (frame-by-frame) Key press handling
            keys = pygame.key.get_pressed()
            if keys[pygame.K_LEFT]:
                self.player.rect.x -= self.player.SPEED
            if keys[pygame.K_RIGHT]:
                self.player.rect.x += self.player.SPEED

            #######################
            # 2. RULES SECTION
            #######################
            ### Level-specifc stuff:
            if time_clock > LEVEL_DELAY:
                commands = self.level.tick_hook()

                for cmd in commands:
                    if cmd == "create zombie":
                        self.create_zombie()

                    if cmd == "create spaceship":
                        self.create_spaceship()

                    if cmd == "go to level2":
                        self.kill_enemies()
                        time_start = time.time() * 1000
                        self.level = Level(2, player)

                    if cmd == "go to level3":
                        self.kill_enemies()
                        time_start = time.time() * 1000
                        self.level = Level(3, self.player)
                    if cmd == "go to level4":
                        self.kill_enemies()
                        time_start = time.time() * 1000
                        self.level = Level(4, self.player)

            # 2b. rules for bullets
            # 2b.1. Update the bullets position.
            self.bullets.update()

            # Update all stars.
            for i in range(len(self.stars)):
                (x, y) = self.stars[i]
                y = y + 1

                if y > Screen.HEIGHT:
                    x = random.randint(0, Screen.WIDTH)
                    y = 0

                self.stars[i] = (x, y)

            if time_clock > LEVEL_DELAY:
                # 2a rules for the square
                # Keep the square within bounds
                self.player.update()

                # 2c. rules for zombies
                # 2c.1. Update the zombies position.
                self.zombies.update()
                self.spaceships.update()

            # Clear the screen
            self.window.screen.fill(Color.BLACK)

            # Draw stars first (because its a background)
            for s in self.stars:
                pygame.draw.rect(self.window.screen, "white", pygame.Rect(s[0], s[1], 2, 2))

            # Draw the square
            # pygame.draw.rect(screen, square_color, (square_x, square_y, square_size, square_size))
            self.window.screen.blit(self.player.image, self.player.rect)

            if time_clock > LEVEL_DELAY:
                # Draw the zombies.
                self.zombies.draw(self.window.screen)
                self.spaceships.draw(self.window.screen)

                # ships make a sound, if...
                if self.spaceships:
                    if frame_counter == 30:
                        self.sound.play("pellet")

            # Draw the bullets.
            self.bullets.draw(self.window.screen)

            # write score.
            if frame_counter < 30:
                s = "1UP"
                text_surface = self.window.font.render(s, True, "white")
                self.window.screen.blit(text_surface, (96, 10))

            s = f"{self.player.score:02}"
            text_surface = self.window.font.render(s, True, "red")
            self.window.screen.blit(text_surface, (160, 42))

            # do high score.
            s = "HIGH SCORE"
            text_surface = self.window.font.render(s, True, "white")
            self.window.screen.blit(text_surface, (320, 10))

            s = f"{self.player.hiscore:02}"
            text_surface = self.window.font.render(s, True, "red")
            self.window.screen.blit(text_surface, (512, 42))

            s = f"{self.level.level_number}"
            text_surface = self.window.font.render(s, True, "red")
            self.window.screen.blit(text_surface, (700, 42))

            if time_clock < LEVEL_DELAY:
                s = f"Level {self.level.level_number}"
                text_surface = self.window.font.render(s, True, "white")
                tr = text_surface.get_rect()
                tr.center = (Screen.WIDTH // 2, Screen.HEIGHT // 2 - 100)
                self.window.screen.blit(text_surface, tr)

            # Update the display
            pygame.display.flip()

            if time_clock > LEVEL_DELAY:
                # 3. INTERSPRITE COLLISION
                # 3a. bullets kill zombies
                collisions = pygame.sprite.groupcollide(self.bullets, self.zombies, True, True)
                collisions2 = pygame.sprite.groupcollide(self.bullets, self.spaceships, True, True)

                if collisions:
                    self.player.score = self.player.score + len(collisions)
                    if self.player.score > self.player.hiscore:
                        self.player.hiscore = self.player.score

                if collisions or collisions2:
                    n = random.randint(1, 2)
                    if n == 1:
                        self.sound.play("boom")
                    else:
                        self.sound.play("boom7")

                if collisions2:
                    self.player.score = self.player.score + (len(collisions2) * 10)
                    if self.player.score > self.player.hiscore:
                        self.player.hiscore = self.player.score

                # Players may not touch zombies:
                collided_enemies = pygame.sprite.spritecollide(self.player, self.zombies, False)

                if collided_enemies:
                    print("You are DEAD!")
                    print(" High score: " + str(self.player.hiscore))
                    print(" Your score: " + str(self.player.score))
                    self.quit_game()

            # Control the frame rate
            clock.tick(60)

    #################################
    ##      Support Functions      ##
    #################################

    def create_bullet(self, x, y, dx, dy):
        self.bullet = Bullet(x, y, dx, dy)
        self.bullets.add(self.bullet)
        self.sound.play("laser")
        if Constants.VERBOSE:
            print("bullet created")

    def create_zombie(self):
        sx = random.randint(50, Screen.WIDTH - 50)
        sy = 0 + Screen.MARGIN
        dx = 0
        dy = 1
        z = Zombie(sx, sy, dx, dy)
        self.zombies.add(z)
        if Constants.VERBOSE:
            print("zombie created")

    def create_spaceship(self):
        sx = Screen.WIDTH
        sy = 0 + Screen.MARGIN
        dx = -1
        dy = 0

        if random.randint(1, 2) == 1:
            dx = 1
            sx = 0

        s = SpaceShip(sx, sy, dx, dy)
        self.spaceships.add(s)
        if Constants.VERBOSE:
            print("spaceship created")

    def kill_enemies(self):
        for z in self.zombies:
            z.kill()
        for s in self.spaceships:
            s.kill()

    # Save the score to a text file.
    def save_hiscore(self, filename, score):
        with open(filename, 'w') as file:
            file.write(str(score))

    # Load the score from a text file.
    def load_hiscore(self, filename):
        try:
            with open(filename, 'r') as file:
                score = int(file.read())
                return score
        except:
            print(f"Error. Resetting high score to 0.")
            return 0

    def quit_game():
        self.save_hiscore("score.txt", str(self.player.hiscore))
        pygame.quit()
        quit()

import random

class Level:

    def __init__(self, n, p):
        self.level_number = n
        self.player = p

        match self.level_number:
            case 1:
                self.tick_hook = self.level1

            case 2:
                self.tick_hook = self.level2

            case 3:
                self.tick_hook = self.level3

            case 4:
                self.tick_hook = self.level4

            case default:
                print("Unknown Level Number: " + str(n))
                print("Defaulting to Level 1!")
                self.tick_hook = self.level1

        return


##### Tick Hooks
    def level1(self):
        commands = []

        if random.randint(1,45) == 1:
            commands.append("create zombie")

        if self.player.score >= 20:
            commands.append("go to level2")

        return commands


    def level2(self):
        commands = []

        if random.randint(1, 35) == 1:
            commands.append("create zombie")

        if self.player.score >= 40:
            commands.append("go to level3")

        return commands

    def level3(self):
        commands = []

        if random.randint(1, 30) == 1:
            commands.append("create zombie")

        if random.randint(1, 500) == 1:
            commands.append("create spaceship")

        if self.player.score >= 80:
            commands.append("go to level4")

        return commands

    def level4(self):
        commands = []

        if random.randint(1, 20) == 1:
            commands.append("create zombie")

        if random.randint(1, 350) == 1:
            commands.append("create spaceship")

        #if self.player.score > 320:
        #    commands.append("go to level5")

        return commands

import pygame

class Object(pygame.sprite.Sprite):
    def __init__(self, x, y, width, height, name=None):
        super().__init__()
        self.rect = pygame.Rect(x, y, width, height)
        self.image = pygame.Surface((width, height), pygame.SRCALPHA)
        self.width = width
        self.height = height
        self.name = name

    def draw(self, win, offset_x, offset_y):
        win.blit(self.image, (self.rect.x - offset_x, self.rect.y + offset_y))

import pygame
import time
from Color import *
from Screen import *

# Define the Bullet Sprite class
class Player(pygame.sprite.Sprite):
    SPEED = 5
    SIZE = 20
    COLOR = Color.WHITE

    def __init__(self):
        super().__init__()
        self.ticks = 0
        self.loops = 0

        # Create a surface for the bullet
        self.image = pygame.Surface((self.SIZE, self.SIZE))

        # Fill the surface with a color
        self.image.fill(self.COLOR)

        # Get the rectangle for positioning
        self.rect = self.image.get_rect()

        # Set the initial position
        self.rect.center = (Screen.WIDTH//2, Screen.HEIGHT-50)

        self.score = 0
        self.hiscore = 0

    def update(self):
        # Restrict to screen.
        if self.rect.x < 0:
            self.rect.x = 0
        if self.rect.x > Screen.WIDTH - self.SIZE:
            self.rect.x = Screen.WIDTH - self.SIZE
        if self.rect.y < 0:
            self.rect.y = 0
        if self.rect.y > Screen.HEIGHT - self.SIZE:
            self.rect.y = Screen.HEIGHT - self.SIZE

        # Easier to read, but, slower.
        #self.rect.x = max(0, min(self.rect.x, Screen.WIDTH - self.SIZE))
        #self.rect.y = max(0, min(self.rect.y, Screen.HEIGHT - self.SIZE))

import pygame as a

class Sound:
    def __init__(self):
        a.mixer.init()
        dir = 'assets/sound/'
        self.sounds = {}

        self.sounds["laser"] = a.mixer.Sound(dir+'laser1.wav')
        self.sounds["laser"].set_volume(0.15)
        self.sounds["boom"] = a.mixer.Sound(dir+'boom6.wav')
        self.sounds["boom7"] = a.mixer.Sound(dir+'boom7.wav')
        self.sounds["start"] = a.mixer.Sound(dir+'start4.wav')
        self.sounds["pellet"] = a.mixer.Sound(dir+'pellet.wav')

    def play(self, sound):
        if sound in self.sounds:
            self.sounds[sound].play()
        else:
            print(f"There is no {sound} sound!")