vaxman.py

# Pacman in Python with PyGame
# https://github.com/hbokmann/Pacman

import pygame

# defining colors
black = (0, 0, 0)
white = (255, 255, 255)
blue = (0, 0, 255)
green = (0, 255, 0)
red = (255, 0, 0)
purple = (255, 0, 255)
yellow = (255, 255, 0)

Trollicon = pygame.image.load('images/Trollman.png')
pygame.display.set_icon(Trollicon)

# Add music
pygame.mixer.init()
pygame.mixer.music.load('pacman.mp3')
pygame.mixer.music.play(-1, 0.0)


class Wall(pygame.sprite.Sprite):  # This class represents walls
    # Constructor function
    def __init__(self, x, y, width, height, color):
        # Call the parent's constructor
        pygame.sprite.Sprite.__init__(self)

        # Make a blue wall, of the size specified in the parameters
        self.image = pygame.Surface([width, height])
        self.image.fill(color)

        # Make our top-left corner the passed-in location.
        self.rect = self.image.get_rect()
        self.rect.top = y
        self.rect.left = x


class Player(pygame.sprite.Sprite):  # This class represents our vaxman
    # Set speed vector
    change_x = 0
    change_y = 0

    # Constructor function
    def __init__(self, x, y, filename):
        # Call the parent's constructor
        pygame.sprite.Sprite.__init__(self)

        # Set height, width
        self.image = pygame.image.load(filename).convert()

        # Make our top-left corner the passed-in location.
        self.rect = self.image.get_rect()
        self.rect.top = y
        self.rect.left = x
        self.prev_x = x
        self.prev_y = y

    # Clear the speed of the player
    def prevdirection(self):
        self.prev_x = self.change_x
        self.prev_y = self.change_y

    # Change the speed of the player
    def changespeed(self, x, y):
        self.change_x += x
        self.change_y += y

    # Find a new position for the player
    def update(self, walls, gate):
        # Get the old position, in case we need to go back to it

        old_x = self.rect.left
        new_x = old_x + self.change_x
        prev_x = old_x + self.prev_x
        self.rect.left = new_x

        old_y = self.rect.top
        new_y = old_y + self.change_y
        prev_y = old_y + self.prev_y

        # Did this update cause us to hit a wall?
        x_collide = pygame.sprite.spritecollide(self, walls, False)
        if x_collide:
            # Whoops, hit a wall. Go back to the old position
            self.rect.left = old_x
        else:
            self.rect.top = new_y
            # Did this update cause us to hit a wall?
            y_collide = pygame.sprite.spritecollide(self, walls, False)
            if y_collide:
                # Whoops, hit a wall. Go back to the old position
                self.rect.top = old_y

        if gate != False:
            gate_hit = pygame.sprite.spritecollide(self, gate, False)
            if gate_hit:
                self.rect.left = old_x
                self.rect.top = old_y


class Ghost(Player):  # This class represents the ghosts. It is inherited from the player class
    # Change the speed of the ghost
    def changespeed(self, list, ghost, turn, steps, l):
        try:
            z = list[turn][2]
            if steps < z:
                self.change_x = list[turn][0]
                self.change_y = list[turn][1]
                steps += 1
            else:
                if turn < l:
                    turn += 1
                elif ghost == "clyde":
                    turn = 2
                else:
                    turn = 0
                self.change_x = list[turn][0]
                self.change_y = list[turn][1]
                steps = 0
            return [turn, steps]
        except IndexError:
            return [0, 0]


class Dot(pygame.sprite.Sprite):  # This class represents the dots
    # It derives from the "Sprite" class in Pygame

    # Constructor. Pass in the color of the dots,
    # and its x and y position
    def __init__(self, color, width, height):
        # Call the parent class (Sprite) constructor
        pygame.sprite.Sprite.__init__(self)

        # Create an image of the dots, and fill it with a color.
        # This could also be an image loaded from the disk.
        self.image = pygame.Surface([width, height])
        self.image.fill(white)
        self.image.set_colorkey(white)
        pygame.draw.ellipse(self.image, color, [0, 0, width, height])

        # Fetch the rectangle object that has the dimensions of the image
        # image.
        # Update the position of this object by setting the values
        # of rect.x and rect.y
        self.rect = self.image.get_rect()

    # This class represents the bar at the bottom that the player controls


Pinky_directions = [
    [0, -30, 4],
    [15, 0, 9],
    [0, 15, 11],
    [-15, 0, 23],
    [0, 15, 7],
    [15, 0, 3],
    [0, -15, 3],
    [15, 0, 19],
    [0, 15, 3],
    [15, 0, 3],
    [0, 15, 3],
    [15, 0, 3],
    [0, -15, 15],
    [-15, 0, 7],
    [0, 15, 3],
    [-15, 0, 19],
    [0, -15, 11],
    [15, 0, 9]
]

Blinky_directions = [
    [0, -15, 4],
    [15, 0, 9],
    [0, 15, 11],
    [15, 0, 3],
    [0, 15, 7],
    [-15, 0, 11],
    [0, 15, 3],
    [15, 0, 15],
    [0, -15, 15],
    [15, 0, 3],
    [0, -15, 11],
    [-15, 0, 3],
    [0, -15, 11],
    [-15, 0, 3],
    [0, -15, 3],
    [-15, 0, 7],
    [0, -15, 3],
    [15, 0, 15],
    [0, 15, 15],
    [-15, 0, 3],
    [0, 15, 3],
    [-15, 0, 3],
    [0, -15, 7],
    [-15, 0, 3],
    [0, 15, 7],
    [-15, 0, 11],
    [0, -15, 7],
    [15, 0, 5]
]

Inky_directions = [
    [30, 0, 2],
    [0, -15, 4],
    [15, 0, 10],
    [0, 15, 7],
    [15, 0, 3],
    [0, -15, 3],
    [15, 0, 3],
    [0, -15, 15],
    [-15, 0, 15],
    [0, 15, 3],
    [15, 0, 15],
    [0, 15, 11],
    [-15, 0, 3],
    [0, -15, 7],
    [-15, 0, 11],
    [0, 15, 3],
    [-15, 0, 11],
    [0, 15, 7],
    [-15, 0, 3],
    [0, -15, 3],
    [-15, 0, 3],
    [0, -15, 15],
    [15, 0, 15],
    [0, 15, 3],
    [-15, 0, 15],
    [0, 15, 11],
    [15, 0, 3],
    [0, -15, 11],
    [15, 0, 11],
    [0, 15, 3],
    [15, 0, 1],
]

Clyde_directions = [
    [-30, 0, 2],
    [0, -15, 4],
    [15, 0, 5],
    [0, 15, 7],
    [-15, 0, 11],
    [0, -15, 7],
    [-15, 0, 3],
    [0, 15, 7],
    [-15, 0, 7],
    [0, 15, 15],
    [15, 0, 15],
    [0, -15, 3],
    [-15, 0, 11],
    [0, -15, 7],
    [15, 0, 3],
    [0, -15, 11],
    [15, 0, 9],
]

pl = len(Pinky_directions) - 1
bl = len(Blinky_directions) - 1
il = len(Inky_directions) - 1
cl = len(Clyde_directions) - 1


def duplicate_ghost(gi, monster_list, asl):
    if 0 < len(gi[0]) < 32:
        # create X blinkys (X = the number of existing blinkys)
        for k in range(len(gi[0])):
            b = Ghost(w, b_h, "images/Blinky.png")

            gi[0].append(b)
            monster_list.add(b)
            asl.add(b)

    if 0 < len(gi[1]) < 32:
        # create X pinkys (X = the number of existing pinkys)
        for k in range(len(gi[1])):
            p = Ghost(w, b_h, "images/Pinky.png")

            gi[1].append(p)
            monster_list.add(p)
            asl.add(p)

    if 0 < len(gi[2]) < 32:
        # create X inkys (X = the number of existing inkys)
        for k in range(len(gi[2])):
            i = Ghost(w, b_h, "images/Inky.png")

            gi[2].append(i)
            monster_list.add(i)
            asl.add(i)

    if 0 < len(gi[3]) < 32:
        # create X clydes (X = the number of existing clydes)
        for k in range(len(gi[3])):
            c = Ghost(w, b_h, "images/Clyde.png")

            gi[3].append(c)
            monster_list.add(c)
            asl.add(c)

    pygame.time.set_timer(pygame.USEREVENT + 1,
                          1000 * 30)  # reset the timer

# This creates all the walls in room 1


def setupRoomOne(all_sprites_list):
    # Make the walls. (x_pos, y_pos, width, height)
    wall_list = pygame.sprite.RenderPlain()

    # This is a list of walls. Each is in the form [x, y, width, height]
    walls = [[0, 0, 6, 600],
             [0, 0, 600, 6],
             [0, 600, 606, 6],
             [600, 0, 6, 606],
             [300, 0, 6, 66],
             [60, 60, 186, 6],
             [360, 60, 186, 6],
             [60, 120, 66, 6],
             [60, 120, 6, 126],
             [180, 120, 246, 6],
             [300, 120, 6, 66],
             [480, 120, 66, 6],
             [540, 120, 6, 126],
             [120, 180, 126, 6],
             [120, 180, 6, 126],
             [360, 180, 126, 6],
             [480, 180, 6, 126],
             [180, 240, 6, 126],
             [180, 360, 246, 6],
             [420, 240, 6, 126],
             [240, 240, 42, 6],
             [324, 240, 42, 6],
             [240, 240, 6, 66],
             [240, 300, 126, 6],
             [360, 240, 6, 66],
             [0, 300, 66, 6],
             [540, 300, 66, 6],
             [60, 360, 66, 6],
             [60, 360, 6, 186],
             [480, 360, 66, 6],
             [540, 360, 6, 186],
             [120, 420, 366, 6],
             [120, 420, 6, 66],
             [480, 420, 6, 66],
             [180, 480, 246, 6],
             [300, 480, 6, 66],
             [120, 540, 126, 6],
             [360, 540, 126, 6]
             ]

    # Loop through the list. Create the wall, add it to the list
    for item in walls:
        wall = Wall(item[0], item[1], item[2], item[3], blue)
        wall_list.add(wall)
        all_sprites_list.add(wall)

    # return our new list
    return wall_list

# This is where the gate that allows ghosts to come out of


def setupGate(all_sprites_list):
    gate = pygame.sprite.RenderPlain()
    gate.add(Wall(282, 242, 42, 2, white))
    all_sprites_list.add(gate)
    return gate


# Call this function so the Pygame library can initialize itself
pygame.init()

# Create an 606x606 sized screen
screen = pygame.display.set_mode([606, 606])

# Set the title of the window
pygame.display.set_caption('Vaxman')

# Create a surface we can draw on
background = pygame.Surface(screen.get_size())

# Used for converting color maps and such
background = background.convert()

# Fill the screen with a black background
background.fill(black)

# Initiate a pygame clock to control the frame rate of our game
clock = pygame.time.Clock()

# setting font
pygame.font.init()
font = pygame.font.Font("freesansbold.ttf", 24)

# default locations for Pacman and monsters
w = 303 - 16  # Width
p_h = (7 * 60) + 19  # Pacman height
m_h = (4 * 60) + 19  # Monster height
b_h = (3 * 60) + 19  # Binky height
i_w = 303 - 16 - 32  # Inky width
c_w = 303 + (32 - 16)  # Clyde width


def startGame():
    # render groups
    all_sprites_list = pygame.sprite.RenderPlain()
    dot_list = pygame.sprite.RenderPlain()
    monster_list = pygame.sprite.RenderPlain()
    pacman_collide = pygame.sprite.RenderPlain()
    wall_list = setupRoomOne(all_sprites_list)

    # initialise gate
    gate = setupGate(all_sprites_list)

    p_turn = 0
    p_steps = 0

    b_turn = 0
    b_steps = 0

    i_turn = 0
    i_steps = 0

    c_turn = 0
    c_steps = 0

    # Initialising the objects of our game
    Pacman = Player(w, p_h, "images/Trollman.png")
    all_sprites_list.add(Pacman)
    pacman_collide.add(Pacman)

    Blinky = Ghost(w, b_h, "images/Blinky.png")
    monster_list.add(Blinky)
    all_sprites_list.add(Blinky)

    Pinky = Ghost(w, m_h, "images/Pinky.png")
    monster_list.add(Pinky)
    all_sprites_list.add(Pinky)

    Inky = Ghost(i_w, m_h, "images/Inky.png")
    monster_list.add(Inky)
    all_sprites_list.add(Inky)

    Clyde = Ghost(c_w, m_h, "images/Clyde.png")
    monster_list.add(Clyde)
    all_sprites_list.add(Clyde)

    blinky_instances = [Blinky]
    pinky_instances = [Pinky]
    inky_instances = [Inky]
    clyde_instances = [Clyde]

    # list of all ghosts
    ghost_instances = [blinky_instances,
                       pinky_instances,
                       inky_instances,
                       clyde_instances]

    # set the timer before the game loop
    pygame.time.set_timer(pygame.USEREVENT + 1, 1000 * 30)

    # instantiate dots
    for row in range(19):
        for column in range(19):
            if (row == 7 or row == 8) and (column == 8 or column == 9 or column == 10):
                continue
            else:
                dot = Dot(yellow, 4, 4)

                # Set a random location for the dot
                dot.rect.x = (30 * column + 6) + 26
                dot.rect.y = (30 * row + 6) + 26

                b_collide = pygame.sprite.spritecollide(
                    dot, wall_list, False)
                p_collide = pygame.sprite.spritecollide(
                    dot, pacman_collide, False)
                if b_collide:
                    continue
                elif p_collide:
                    continue
                else:
                    # Add the dot to the list of objects
                    dot_list.add(dot)
                    all_sprites_list.add(dot)

    bll = len(dot_list)

    score = 0

    running = True

    i = 0

    while running:
        # EVENT PROCESSING
        for event in pygame.event.get():
            # CHANGE - add timer for doubling the ghosts
            if event.type == pygame.USEREVENT + 1:  # if the timer is up
                duplicate_ghost(ghost_instances, monster_list,
                                all_sprites_list)

            # CHANGE - quit game
            if event.type == pygame.QUIT:
                running = False

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    Pacman.changespeed(-30, 0)
                if event.key == pygame.K_RIGHT:
                    Pacman.changespeed(30, 0)
                if event.key == pygame.K_UP:
                    Pacman.changespeed(0, -30)
                if event.key == pygame.K_DOWN:
                    Pacman.changespeed(0, 30)

            if event.type == pygame.KEYUP:
                if event.key == pygame.K_LEFT:
                    Pacman.changespeed(30, 0)
                if event.key == pygame.K_RIGHT:
                    Pacman.changespeed(-30, 0)
                if event.key == pygame.K_UP:
                    Pacman.changespeed(0, 30)
                if event.key == pygame.K_DOWN:
                    Pacman.changespeed(0, -30)

        # ALL EVENT PROCESSING SHOULD GO ABOVE THIS COMMENT

        # ALL GAME LOGIC SHOULD GO BELOW THIS COMMENT
        Pacman.update(wall_list, gate)

        # Updating all pinkys
        for i in range(len(pinky_instances)):
            returned = pinky_instances[i].changespeed(
                Pinky_directions, False, p_turn, p_steps, pl)
            p_turn = returned[0]
            p_steps = returned[1]
            pinky_instances[i].changespeed(
                Pinky_directions, False, p_turn, p_steps, pl)
            pinky_instances[i].update(wall_list, False)

        # Updating all blinkys
        for i in range(len(blinky_instances)):
            returned = blinky_instances[i].changespeed(
                Blinky_directions, False, b_turn, b_steps, bl)
            b_turn = returned[0]
            b_steps = returned[1]
            blinky_instances[i].changespeed(
                Blinky_directions, False, b_turn, b_steps, bl)
            blinky_instances[i].update(wall_list, False)

        # Updating all inkys
        for i in range(len(inky_instances)):
            returned = inky_instances[i].changespeed(
                Inky_directions, False, i_turn, i_steps, il)
            i_turn = returned[0]
            i_steps = returned[1]
            inky_instances[i].changespeed(
                Inky_directions, False, i_turn, i_steps, il)
            inky_instances[i].update(wall_list, False)

        # Updating all clydes
        for i in range(len(clyde_instances)):
            returned = clyde_instances[i].changespeed(
                Clyde_directions, False, c_turn, c_steps, cl)
            c_turn = returned[0]
            c_steps = returned[1]
            clyde_instances[i].changespeed(
                Clyde_directions, False, c_turn, c_steps, cl)
            clyde_instances[i].update(wall_list, False)

        # See if the Pacman dot has collided with anything.
        dots_hit_list = pygame.sprite.spritecollide(Pacman, dot_list, True)

        # Check the list of collisions.
        if len(dots_hit_list) > 0:
            score += len(dots_hit_list)

        # ALL GAME LOGIC SHOULD GO ABOVE THIS COMMENT

        # ALL CODE TO DRAW SHOULD GO BELOW THIS COMMENT
        screen.fill(black)
        wall_list.draw(screen)
        gate.draw(screen)
        all_sprites_list.draw(screen)
        monster_list.draw(screen)

        text = font.render("Score: " + str(score) + "/" + str(bll), True, red)
        screen.blit(text, [10, 10])

        textg = font.render("Ghosts: " + str(len(monster_list)), True, red)
        screen.blit(textg, [450, 10])

        if score == bll:
            runningxt("Congratulations, you won!", 145, all_sprites_list, dot_list, monster_list,
                      pacman_collide, wall_list, gate)

        monster_hit_list = pygame.sprite.spritecollide(
            Pacman, monster_list, False)

        if monster_hit_list:
            for monster in monster_hit_list:
                # remove all instances from monster_list that are in monster_hit_list
                monster_list.remove(monster)
                # remove from instance lists so only the ghosts remaining can multiply
                if monster is Blinky:
                    blinky_instances.remove(monster)
                elif monster is Pinky:
                    pinky_instances.remove(monster)
                elif monster is Clyde:
                    clyde_instances.remove(monster)
                elif monster is Inky:
                    inky_instances.remove(monster)
                # remove all instances from all_sprites_list that are in monster_hit_list
                all_sprites_list.remove(monster)

        if len(monster_list) >= 128:
            runningxt("Game Over", 235, all_sprites_list, dot_list, monster_list, pacman_collide,
                      wall_list, gate)

        # ALL CODE TO DRAW SHOULD GO ABOVE THIS COMMENT

        pygame.display.flip()

        clock.tick(10)


def runningxt(message, left, all_sprites_list, dot_list, monster_list, pacman_collide, wall_list, gate):
    while True:
        # ALL EVENT PROCESSING SHOULD GO BELOW THIS COMMENT
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    pygame.quit()
                if event.key == pygame.K_RETURN:
                    del all_sprites_list
                    del dot_list
                    del monster_list
                    del pacman_collide
                    del wall_list
                    del gate
                    startGame()

        # Grey background
        w = pygame.Surface((400, 200))  # the size of your rect
        w.set_alpha(10)  # alpha level
        w.fill((128, 128, 128))  # this fills the entire surface
        screen.blit(w, (100, 200))  # (0,0) are the top-left coordinates

        # Won or lost
        text1 = font.render(message, True, white)
        screen.blit(text1, [left, 233])
        text2 = font.render("To play again, press ENTER.", True, white)
        screen.blit(text2, [135, 303])
        text3 = font.render("To quit, press ESCAPE.", True, white)
        screen.blit(text3, [165, 333])

        pygame.display.flip()

        clock.tick(10)


startGame()

pygame.quit()