Files

Creator’s ZIP folder of all the completed files. The ‘run.py’ file is the home base where the game is played.

This is my (Grant’s) version of the same files, denoted by the ‘1’ in the names. Neither is perfect, we both have unique flaws. I recommend downloading both versions and experimenting with how the games run.

This is a ZIP folder of the codes for each milestone of the game’s creation. These are based on my version, not the creator’s. Make sure your indentations are uniform when pasting this into your IDE.

Troubleshoot tips: While the non-Python files are in the zip folder, make sure they’re also in the home base folder that the zip folder lies in. You’ll likely have to copy and paste them.

Intro & Overview

So I first did Pong as a way to practice Python outside of random exercises. I learned a little but it still left out a lot of features of the language. So to take it up a notch, I’m remaking Pacman entirely in Python. This involves every feature of the language from functions to loops, libraries, and dictionaries.

I found this amazing website pacmancode.com that walks through the process of coding the game in Python. I couldn’t find the creator’s name, but I commend him for making this. This is what educational content creation is all about: create what you wish had existed when you were starting out.

Ima be straight with yall, this isn’t perfect. It’s not fully functional arcade-ready. Even running the code the creator made still has some issues. The characters are misaligned, the button feedback is stiff, and a few other things. I just did this to get more practice in Python. I have more important things to do with it, so I wasn’t gonna spend all my time correcting each and every error. So again, this won’t be a polished version, but the base will be there. I may revise this later, but don’t take it too serious.

So first I’ll give yall an overview of the sections we’ll be going through. We’ll start with the game area, which is the maze. We’ll set up a bare-bones version of Pacman and his basic movement. Then we’ll move on to the nodes that will make up the maze. This is the most tedious part of the process. Luckily it’s in the early stages so we’re getting this out the way. Then we’ll set the features of the maze, like its borders, portals, and pellets. We’ll be connecting these features to Pacman during this part too. The hump of this project is the ghosts. We’ll spend a chunk of time on them. Creating them, setting their different chase styles, and setting the modes of the game which include Pacman eating a power pellet, followed by him eating a ghost, the short time when a ghost is eaten and rushes back to its home base, and dying from a ghost. After that, we’ll handle the auxiliary game mechanics like the character’s starting positions, the fruit, Pacman’s lives, pausing, and ending a level. One big thing I couldn’t figure out in time is reviving Pacman after he loses a life. I got his death animation down, but if he loses a life, an error pops up, and it’s too layered to focus on. So I’ll admit this is the main game-breaking flaw I had to leave in. If you’re testing this code and running the game as you follow along, don’t let him die. After that, it’s really all aesthetics from this point on. We’ll be using a pre-made sprite sheet that contains all the images from the original game. Remember some objects actually change shape instead of just moving, like Pacman’s death or the ghosts’ eyes. These are animations, which means you’ll need each frame of the object in a different state. The sprite sheet saves us time from having to create all of that from scratch.

Setup

All you need to set this up is a working computer. Download the Python language from the official site, it’s free. And you’ll only need to install 2 libraries: Pygame (obviously) and NumPy which we’ll be using to add the nodes into a data structure. To install these libraries, open your computer’s terminal, it may be called ‘command prompt’ or ‘PowerShell’, and type “pip install pygame numpy“. This will install both libraries for you. Again, this is all free and takes up little space. You’ll also need an editor to actually type the code into. I used the IDLE that comes with Python when you download it, so that’ll work for you too; just search for the ‘IDLE’ app on your computer. You don’t have to use this one, but any other one is gonna add complications if you’re not already used to it. This is the basic word doc for writing code in Python.

We’re also going to be using many separate files that’ll be imported into each other. So I suggest creating a folder to hold those files.

After going through this whole thing, I have a 3-step heuristic for how Python works: If you want to move an apple, you first have to state that there is an apple, then you have to state there are things you’d like to do with the apple, then you move the apple. Just about any error, outside of spelling or spacing, happens because one of these steps was missed. The ‘init’ method will usually hold the first step. The use of ‘self’ is for the sake of the second step in most cases, and the other methods is where the actual work is done.

Vectors

Starting off, as with any game, there’s the space of the play area. This space is a grid. To get from point A to point B, I would give you 2 sets of information: distance and direction. “Go up 3 blocks, turn right for 2 blocks, hang a left, then stay straight for 5 blocks.”

Create a file called ‘vectors’, and make sure it’s a Python file, which you can tell by it ending in ‘.py’. This first code imports a ‘math’ package to use predefined functions.

import math

class Vector2(object):
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
        self.thresh = 0.000001

x and y represent the coordinates the vector is pointing towards. As with any initialize (init) function, we start the arguments with ‘self’ and establish them with themselves using a ‘self’ reference.

The arithmetic we’ll be doing is adding and subtracting vectors along with multiplying and dividing vectors by scalars; in that order.

def __add__(self, other):
        return Vector2(self.x + other.x, self.y + other.y)

def __sub__(self, other):
    return Vector2(self.x - other.x, self.y - other.y)

def __neg__(self):
    return Vector2(-self.x, -self.y)

def __mul__(self, scalar):
    return Vector2(self.x * scalar, self.y * scalar)

def __div__(self, scalar):
    if scalar != 0:
        return Vector2(self.x / float(scalar), self.y / float(scalar))
    return None

def __truediv__(self, scalar):
    return self.__div__(scalar)

For the first 2, addition and subtraction, ‘self’ is the current Vector2 instance, and ‘other’ will be whatever other number we put in the equation. The next one ‘neg’ makes the coordinates negative. The next 2 ‘mul’ and ‘div’ do their respective operations. They’re set to scalar which is standard arithmetic when dealing with vectors. The ‘div’ sets its scalars to be floating-point (allowing decimals) to ensure precision.

The regular ‘div’ is for Python 3 and the ‘truediv’ is for Python 2. Ensuring this can play on the current and previous versions.

This method checks for equality between 2 vectors. In scientific computing, 3 and 3.000001 are usually considered as different, but they can suffice as equal for this case Our ‘self.thresh’ variable is the threshold tolerance for the biggest difference the equality checker will allow. We subtract the 2 values to see if the difference is smaller than our threshold value. The ‘abs’ is what calculates the absolute value of the number it’s passed.

def __eq__(self, other):
    if abs(self.x - other.x) < self.thresh:
        if abs(self.y - other.y) < self.thresh:
            return True
    return False

Here we have 2 magnitude methods. ‘magnitude’ returns the actual length of the vector which requires a square root (which is why we had to import the ‘math’ package). ‘magnitudeSquared’ is the method we’ll be calling throughout the game since it does the squaring for us.

def magnitudeSquared(self):
    return self.x**2 + self.y**2

def magnitude(self):
    return math.sqrt(self.magnitudeSquared())

This string method doesn’t have any functionality for the game. It’s used to print out the vector and make it more accessible. This is for organizational purposes.

def __str__(self):
    return "<"+str(self.x)+", "+str(self.y)+">"

This ‘copy’ method will copy a vector so we get a new instance of it. The other 2 methods convert our vector into a tuple and an int(eger) tuple which will make the code cleaner for later.

def copy(self):
    return Vector2(self.x, self.y)

def asTuple(self):
    return self.x, self.y

def asInt(self):
    return int(self.x), int(self.y)

Blank Screen

We store all of our constants (values that don’t change) in one file we’ll call constants. Make sure it’s still a Python file too.

TILEWIDTH = 16
TILEHEIGHT = 16
NROWS = 36
NCOLS = 28
SCREENWIDTH = NCOLS*TILEWIDTH
SCREENHEIGHT = NROWS*TILEHEIGHT
SCREENSIZE = (SCREENWIDTH, SCREENHEIGHT)
BLACK = (0, 0, 0)

Our next lines serve as an entry point into our game. We create a run.py file that’ll be the main one we use to run the game. Every other file will be imported into this one.

Then we create a GameController class followed by a Pygame initialization, defining the screen using the values from the constants file, and calling a method that sets up the background (which we haven’t created yet). In run.py

import pygame
from pygame.locals import *
from constants import *

class GameController(object):
    def __init__(self):
        pygame.init()
        self.screen = pygame.display.set_mode(SCREENSIZE, 0, 32)
        self.background = None

Next we set the background color to black.

def setBackground(self):
    self.background = pygame.surface.Surface(SCREENSIZE).convert()
    self.background.fill(BLACK)

We’re gonna set the ‘start game’ and ‘update’ methods to be used later.

def startGame(self):
    self.setBackground()

def update(self):
    self.checkEvents()
    self.render()

Then we set the ‘checkEvents’ method for quitting the game. Without this, the X wouldn’t do anything. Yes, you have to manually tell a program that you will want to close it at some point. The ‘render’ method is to initialize the drawings we’ll be doing. In run.py

def checkEvents(self):
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()

def render(self):
    pygame.display.update()

This block will be at the very bottom of the run.py file. The ‘if’ checks if the script being run is the main program. The ‘game’ variable after that creates an instance of the GameController class. Again, if you want to work with something, you have to establish it, and then tell it you want to work with it. This takes care of the second part.

The ‘game.startGame()’ calls the ‘startGame’ method on the ‘game’ object; calling it to be used. Below that is an infinite loop for the ‘update’ method that continually advances the game through whatever state it needs to.

class GameController(object):
    ...

    if __name__ == "__main__":
        game = GameController()
        game.startGame()
        while True:
            game.update()

At this point, when you run the run.py file, a blank pygame screen should pop up.

Basic Movement

This part takes a bit of physics. The equation s(Δt) = s₀ + vΔt + ½*aΔt² represents one-dimensional motion. s₀ is our current position, regardless if it’s x or y. V is our velocity which is speed and direction. s(Δt) is our new position. Δt is the time it’ll take to get to this new position. a is the acceleration of an object as it’s moving towards that new position. In this case, anything that’s moving in the game is either moving at full speed or not moving at all. Acceleration entails speeding up or slowing down, which isn’t a factor in this game. That said, we can set our acceleration to 0 since it’s not involved in the mechanics. We can now cut out everything after that second plus in the equation and simplify it to s(Δt) = s₀ + vΔt.

So to calculate our new position, all we need is our current position, the direction and speed we want to move in, and the time it will take to get there. That’s 3 simple variables. We’re gonna handle some timing issues later on.

Next we initialize a time clock at the end of the ‘init’ method of the GameController class. In run.py

def __init__(self)
...
    self.clock = pygame.time.Clock()

Next we’re adding this ‘dt’ (delta time) variable as the first line of the ‘update’ method which returns the amount of time that has passed since the last time this line was called. 30 is the frame rate. We divide it by 1000 so the result is in seconds and not milliseconds. Overall, this is the game’s time tracker. When we want to manipulate how long certain things last, like the bonus fruit or the ghosts’ vulnerability, this variable helps the game recognize the passage of time so it knows how to mark when something should occur. This is placed in the ‘update’ method since the game will continually have to do this.

The 2 bottom ‘self’ statements were already there. We’re adding the ‘dt’ variable.

def update(self):
    dt = self.clock.tick(30) / 1000.0
    self.checkEvents()
    self.render()

Next we’re defining our constants starting with Pacman’s color, he’s yellow, which is a mix of red and green. So we set those values to 255 and leave blue at 0.

YELLOW = (255, 255, 0)

STOP = 0
UP = 1
DOWN = -1
LEFT = 2
RIGHT = -2

PACMAN = 0

With those in place, we can now draw the man himself. We’re creating a new file called pacman.py for this.

We import pygame of course. The ‘pygame.locals’ line is a module within Pygame that’ll recognize and operate certain keywords when we use them. The asterisk after that is to import all the properties of this module. Otherwise, when we use them, we’d have to put ‘pygame.locals’ before each one, which is tedious. This has to be manually done since Pygame is a big library with too many modules to import all at once. And of course, we import the Vector2 class from the ‘vector’ file and bring over all of the ‘constants’ file.

So we create the Pacman class. The ‘object’ argument tells the class to inherit from a base ‘object’ class. This was standard in Python 2, but automatically done in Python 3. So we could technically leave it out and have it still work.

As with any class, we start with an ‘init’ method to initialize everything. We add these instance variables that will hold the data for his characteristics. We first got his name and his initial position on the game board (which is 200, 400).

This ‘self.directions’ instance creates a dictionary that controls his movement in response to certain key presses. Pacman’s initial direction is STOP since we don’t want him moving unless we say so. In Pygame coordinates, a positive x-vector is right and a positive y-vector is down. So when we want him to move up, when we press the ‘up’ key, his y-vector is set to negative, and vice versa for the down key and moving down. The same applies to left and right.

Part 2

After that, we have a ‘self.direction’ variable that’s set to ‘STOP’. Since this is the ‘init’ method, that means initially, Pacman is stopped.

Speed and color speak for themselves. The radius means we’re making his circle 10 pixels.

In the ‘update’ method, the first line updates Pacman’s position based on his current speed and direction, while also accounting for the passage of time (dt). Again ‘self.position’ is his starting position (200, 400). The other side of the equation calculates his new position and compares it to the starting.

We then set a ‘direction’ variable to check for the key that was pressed. To which that is then set by ‘self.direction’. Essentially, ‘direction’ starts at STOP, which is nothing, yet as we go on (which is the function of the ‘update’ method), the variable updates to the respective direction of the key that was pressed.

import pygame
from pygame.locals import *
from vector import Vector2
from constants import *

class Pacman(object):
    def __init__(self):
        self.name = PACMAN
        self.position = Vector2(200, 400)
        self.directions = {STOP:Vector2(), UP:Vector2(0,-1), DOWN:Vector2(0,1), LEFT:Vector2(-1,0), RIGHT:Vector2(1,0)}
	self.direction = STOP
        self.speed = 100
        self.radius = 10
        self.color = YELLOW

    def update(self, dt):	
        self.position += self.directions[self.direction]*self.speed*dt
        direction = self.getValidKey()
        self.direction = direction

We just called the ‘getValidKey’ object. Now we have to define its entailments to check for which key the player is pressing. Each key returns the direction it corresponds to. These are all ‘True/False’ Boolean values. Whichever one turns ‘True’ is the one that is returned. If none of the keys are pressed, and Pacman hits a wall, it defaults to ‘STOP’.

def getValidKey(self):
       key_pressed = pygame.key.get_pressed()
    if key_pressed[K_UP]:
        return UP
    if key_pressed[K_DOWN]:
        return DOWN
    if key_pressed[K_LEFT]:
        return LEFT
    if key_pressed[K_RIGHT]:
        return RIGHT
    return STOP

Now for the actual drawing. We initialize it with the ‘render’ method. The ‘self’ argument refers to Pacman himself and ‘screen’ is where we’re placing him. For the ‘p’ variable, we’re converting ‘self.position’ to integers, hence the ‘asInt’ method. We do this because coordinates are stated as floating-point numbers, meaning decimals. Converting these to integers helps us keep Pacman’s position precise. And lastly we use the ‘pygame.draw.circle’ method which, you guessed it, actually draws the circle. The ‘screen’ argument obviously puts it onto the screen. The other 3 are Pacman’s characteristics which pertain to his appearance: his color, the ‘p’ variable we just set for his position, and his radius which pertains to his size since he’s a circle.

def render(self, screen):
    p = self.position.asInt()
    pygame.draw.circle(screen, self.color, p, self.radius)

Now that we’ve set the Pacman class, we can go back to our run.py file and implement him.

First we import him. The first ‘pacman’ is the file we just came from. The second ‘Pacman’ is the class that holds the man himself.

from pacman import Pacman 

We add ‘self.pacman = Pacman()’ to the ‘startGame’ method. ‘self.pacman’ will allow us to call the Pacman class where we defined his characteristics. The ‘Pacman()’ set to it is the actual class.

def startGame(self):
    self.setBackground()
    self.pacman = Pacman()

In the ‘update’ method, right under the ‘dt’ variable, we make a call to Pacman’s ‘update’ method passing in that ‘dt’ as an argument, which is its resulting value. This connects the game’s time tracker to Pacman.

def update(self):
    dt = self.clock.tick(30) / 1000.0
    self.pacman.update(dt)
    self.checkEvents()
    self.render()

Lastly, we add 2 lines to our ‘render’ method. The ‘screen.blit’ line redraws the background. Otherwise any object that moves would appear to be smearing across the display. The objects need to be erased and redrawn in their new positions.

And the last ‘render’ line is the final touch to put Pacman onto the screen.

def render(self):
    pygame.display.update()
    self.screen.blit(self.background, (0, 0))
    self.pacman.render(self.screen)

At this point, we have a black screen with a yellow circle we can control with the keyboard.

Nodes

Even though we’ve given Pacman the freedom to move, we gotta add constraints so he only moves within the maze.

A node by itself is a piece of information. Its most important trait is its position. 2 nodes that are directly linked are considered neighbors. They’re connected by a path. A collection of connected nodes is a map. The maps in this game will only have up to 4 nodes since Pacman can only move in 4 directions. Also note that a node can only have one neighbor per direction.

These are a set of 7 nodes labeled A-G on a grid. We see that node A has 2 neighbors, B and C. Node D has 3 neighbors, B, C, and E. We identify their position by the numbers on the edge.

We’ll add white and red with their RGB values to our constants.py file which will represent the lines connecting the nodes.

WHITE = (255, 255, 255)
RED = (255, 0, 0)

We’re also creating a separate node file and adding a ‘node’ class. As always we first import pygame. Then import the ‘Vector2’ class and the ‘constants’ file.

As always, we start a new feature with an ‘init’ method to initialize it. It takes the arguments ‘self’ (which is a given), and x & y to specify the node’s position. The next ‘self.position’ does this again to solidify that the nodes will have a position. The next ‘self.neighbors’ line creates a dictionary with all directions. They’re all set to ‘None’ to state that no node has neighbors when it’s first.

The ‘render’ method is what’ll draw the nodes. It takes the arguments ‘self’ and ‘screen’; same function as it was used for making the Pacman character. The ‘for’ loop is set to iterate through all the keys of the ‘self.neighbors’ dictionary we just set; the 4 directions. The ‘.keys()’ is a method call to access the keys in a dictionary. Per the second line, each iteration checks if the neighbor in the current direction is not ‘None’. If it’s not, that means there’s a neighboring node in that direction. The [n] represents whichever key is the current iteration.

The ‘line_start & end’ variables mark the points of the current node for the start and the neighboring node in the current direction for the end. They’re both converted to tuples since Pygame expects coordinates in tuple form.

The 2 ‘draw’ functions at the end draw the white node circles and the red path lines.

import pygame
from vector import Vector2
from constants import *

class Node(object):
    def __init__(self, x, y):
        self.position = Vector2(x, y)
        self.neighbors = {UP:None, DOWN:None, LEFT:None, RIGHT:None}

    def render(self, screen):
        for n in self.neighbors.keys():
            if self.neighbors[n] is not None:
                line_start = self.position.asTuple()
                line_end = self.neighbors[n].position.asTuple()
                pygame.draw.line(screen, WHITE, line_start, line_end, 4)                
                pygame.draw.circle(screen, RED, self.position.asInt(), 12)

Since we’re dealing with a lot of nodes, we’ll make another class called ‘NodeGroup’. All node objects will be kept in a list.

We create the class then create a method ‘setupTestNodes’ to demonstrate how we can manually link the nodes. Each node needs to have its location set upon creation. After that, we link them together adding nodes to the neighbors’ dictionary of each node. Finally, we add all of the nodes to the ‘nodeList’.

When we want to draw all of the nodes we call the ‘render’ method which just loops through the ‘nodeList’ and calls that node’s ‘render’ method.

class NodeGroup(object):
    def __init__(self):
        self.nodeList = []

    def setupTestNodes(self):
        nodeA = Node(80 ,80)
        nodeB = Node(160, 80)
        nodeC = Node(80, 160)
        nodeD = Node(160, 160)
        nodeE = Node(208, 160)
        nodeF = Node(80, 320)
        nodeG = Node(208, 320)
        nodeA.neighbors[RIGHT] = nodeB
        nodeA.neighbors[DOWN] = nodeC
        nodeB.neighbors[LEFT] = nodeA
        nodeB.neighbors[DOWN] = nodeD
        nodeC.neighbors[UP] = nodeA
        nodeC.neighbors[RIGHT] = nodeD
        nodeC.neighbors[DOWN] = nodeF
        nodeD.neighbors[UP] = nodeB
        nodeD.neighbors[LEFT] = nodeC
        nodeD.neighbors[RIGHT] = nodeE
        nodeE.neighbors[LEFT] = nodeD
        nodeE.neighbors[DOWN] = nodeG
        nodeF.neighbors[UP] = nodeC
        nodeF.neighbors[RIGHT] = nodeG
        nodeG.neighbors[UP] = nodeE
        nodeG.neighbors[LEFT] = nodeF
        self.nodeList = [nodeA, nodeB, nodeC, nodeD, nodeE, nodeF, nodeG]

    def render(self, screen):
        for node in self.nodeList:
            node.render(screen)

Now that we have the NodeGroup class written we can create an instance of it in the GameController class back in the run.py file. First import the ‘NodeGroup’ class.

In the ‘startGame’ method we add 2 lines. The first is creating an instance of the ‘NodeGroup()’ class setting it to a variable named ‘self.nodes’. The second line uses that exact variable and calls the ‘setupTestNodes()’ method for it to perform.

The nodes line in the ‘render’ method is the final touch to put them on the screen. The same as we did with Pacman.

from nodes import NodeGroup

def startGame(self):
    self.setBackground()
    self.nodes = NodeGroup()
    self.nodes.setupTestNodes()
    self.pacman = Pacman()

def render(self):
    self.screen.blit(self.background, (0,0))
    self.nodes.render(self.screen)
    self.pacman.render(self.screen)
    pygame.display.update()

At this point, we have a fixed map of nodes along with our mouthless Pacman. He does not yet have any connection to the nodes. They’re a part of the background at this point.

Node Movement I

We have to go through 3 types of node movement. The first is simply having Pacman jump from one to the other with no transition. If node A has node B as its left neighbor, and the player presses the left key, Pacman will jump from A to B.

We have to pass in the list of nodes that make up the maze. Pacman needs his starting node to be defined. So we’ll just set his position to the first node for now.

So in the pacman.py file, we add ‘node’ as a second argument of the ‘init’ class. We add 2 more ‘self’ lines after color. ‘self.node’ set to ‘node’ initializes Pacman’s position to the node. ‘setPosition()’ does the actual tying to it.

Delete the ‘self.position’ line from the ‘init’ and ‘update’ methods.

Then we add a separate ‘setPosition’ method just before the ‘update’ method, which copies the node’s position to Pacman’s. The ‘copy’ method is used to set an independent copy of the node’s position. Without this, modifying ‘setPosition’ would modify Pacman’s position.

def __init__(self, node):
    self.name = PACMAN
    self.directions = {STOP:Vector2(), UP:Vector2(0,-1), DOWN:Vector2(0,1), LEFT:Vector2(-1,0), RIGHT:Vector2(1,0)}        
    self.direction = STOP
    self.speed = 100
    self.radius = 10
    self.color = YELLOW
    self.node = node
    self.setPosition()

def setPosition(self):
    self.position = self.node.position.copy()

We add 2 more lines to the ‘update’ method.

The other two new methods, ‘validDirection’ and ‘getNewTarget’, check whether the key we’re pressing is a valid direction and whether there is a node in that direction. If so, then we move Pacman to that node automatically.

def update(self, dt):    
    self.position += self.directions[self.direction]*self.speed*dt 
    direction = self.getValidKey()
    self.direction = direction
    self.node = self.getNewTarget(direction)
    self.setPosition()
        
def validDirection(self, direction):
    if direction is not STOP:
        if self.node.neighbors[direction] is not None:
            return True
    return False

def getNewTarget(self, direction):
    if self.validDirection(direction):
        return self.node.neighbors[direction]
    return self.node

Next in the run.py file, we modify the ‘startGame’ method so that we pass in the node we want Pacman to start on.

def startGame(self):
    self.setBackground()
    self.nodes = NodeGroup()
    self.nodes.setupTestNodes()
    self.pacman = Pacman(self.nodes.nodeList[0])

At this point, Pacman is now jumping from node to node only using the path to transition. He does not stay between nodes.

Part 2

So far we got Pacman jumping from node to node, but we want to see him moving between the nodes. In this part, he’ll be stopping on each node, even if a key is pressed. While Pacman is between nodes, any other key presses won’t be responsive. We also have to add a STOP condition when he starts to overshoot a node.

We’re adding a new ‘overshotTarget’ method in the pacman.py file that checks if he overshot a node. The ‘if’ loop is the lines that does this with ‘selfTarget’. If it is None, that means there is no target position to compare it with, indicating no overshot, to which it defaults to return False. If ‘selfTarget’ is not None, that means Pacman has overshot his target node. When this happens, the 2 vectors variables are calculated. ‘vec1’ finds the difference from the target position to the current node. ‘vec2’ finds the difference from Pacman’s position (self.position) to the current node. The ‘magnitudeSquared’ method is used to avoid a square root since we’re just comparing 2 distances; it simplifies the numbers.

If Pacman’s distance is greater than or equal to the distance between the 2 nodes, then he has officially overshot the target node.

def overshotTarget(self):
    if self.target is not None:
        vec1 = self.target.position - self.node.position
        vec2 = self.position - self.node.position
        node2Target = vec1.magnitudeSquared()
        node2Self = vec2.magnitudeSquared()
        return node2Self >= node2Target
    return False

Next we’re adding another variable to the ‘init’ method. ‘Self.target’ which is set to ‘node’. The target node is usually the node Pacman needs to move towards, but if Pacman is stationary on a node then the target node is simply None since he has no target.

def __init__(self, node):
...
    self.setPosition()
    self.target = node

In the ‘update’ method, we delete everything below the ‘direction’ variable and replace it with:

def update(self, dt):
...
    if self.overshotTarget():
        self.node = self.target
        self.target = self.getNewTarget(direction)
        if self.target is not self.node:
            self.direction = direction
        else:
            self.direction = STOP
        self.setPosition()

At this point, Pacman now moves smoothly along the path between nodes. No more ‘jumping’

Part 3

Though we’ve seen Pacman move smoothly between nodes, he stops on each node. We also can’t change his direction when he’s traveling between nodes. In this section, we’ll change his movement so that he’ll only stop on a node if he can’t continue on to another node in the direction he is moving. Otherwise he’ll move past the node. We’ll also make it so he can reverse direction. By the end of this section, Pacman’s movement will be completed. It will function the same regardless of what maze you put him in.

We’re gonna create 2 new methods for the Pacman class. The first is ‘reverseDirection’. Whatever direction he’s already moving in, if I press a key of a different direction, it’ll multiply that value by -1, which makes it opposite. If LEFT is 2, pressing RIGHT makes that -2. The same goes for UP being 1 and pressing DOWN makes that -1. This is what the first ‘self.direction’ line does. The ‘temp’ variable temporarily stores ‘self.node’ so its value can be swapped with ‘self.target’s in the next line. Then in the line after that, ‘self.target’ takes the value of ‘temp’ which solidifies the swap.

But once we move Pacman in the opposite direction, we still have to swap the node and target, which leads to our second method.

‘oppositeDirection’ checks if the input direction is the opposite of Pacman’s current direction. The reason I want to check for this is because when Pacman is moving between nodes, the only direction he can move in is his current direction and his opposite direction. If he’s going left, he can either keep going that way, or go right. He shouldn’t be able to move up or down while he’s on that path. So I want to make sure that the input is a valid direction before saying he can move in that direction.

The ‘if’ loop states if the ‘direction’ argument is not ‘STOP’ it checks the condition that ‘direction’ is equal to the opposite of the current direction. So if the current direction (self.direction) is 2, and the ‘direction’ argument is -2, then they’re equal in that case thus it’ll return True.

def reverseDirection(self):
    self.direction *= -1
    temp = self.node
    self.node = self.target
    self.target = temp

def oppositeDirection(self, direction):
    if direction is not STOP:
        if direction == self.direction * -1:
            return True
    return False    

Lastly for this section we’re modifying the ‘update’ method. If the input direction does not get us a new valid target, then we check the current direction Pacman is moving in.

Remove the 2 lines under the ‘else’ and replace it with a ‘self.target’ variable set to the ‘getNewTarget’ object and including the direction. The new ‘if’ statement ensures that Pacman will stop when he hits a wall. Since he continuously moves forward, his target node can only be the same as his current one if he can’t move any more forward; which means he hit a wall. The last ‘else’ statement operates his reverse direction.

def update(self, dt):	
    self.position += self.directions[self.direction]*self.speed*dt
    direction = self.getValidKey()

    if self.overshotTarget():
        self.node = self.target
        self.target = self.getNewTarget(direction)
        if self.target is not self.node:
            self.direction = direction
        else:
            self.target = self.getNewTarget(self.direction)

        if self.target is self.node:
            self.direction = STOP
        self.setPosition()
    else: 
        if self.oppositeDirection(direction):
            self.reverseDirection()

At this point, Pacman can now reverse direction while he’s traveling between nodes.

Maze Basics

Life is short. We don’t have time to create the maze node by node. So we’re gonna generate it automatically. To do this, we’ll create a text file, use that file as an input for some method, and then have that method output the required ‘nodeList’. To keep the file simple, we’ll create a small system of symbols to illustrate nodes and empty spaces for the computer to read.

• “X”: empty space
• “+”: node
• “.”: vertical/horizontal path (connectors)

We’re gonna use the map and add it into the text file. Again, make sure it’s a TEXT file (.txt) and not a Python one.

X X X X X X X X
X + . . + X X X
X . X X . X X X
X + . . + . + X
X . X X X X . X
X . X X X X . X
X + . . . . + X
X X X X X X X X

In the node.py file, we’re first gonna import NumPy.

Add ‘level’ as an argument to the ‘init’ method of ‘NodeGroup’. We’re also gonna delete the ‘setupTestNode’ method. Now on to the additions to the ‘init’ method.

Delete ‘setupTestNodes’ and the ‘self.nodeList’ from ‘init’.

Since we imported Numpy, this will read out the text file and put it into an array, which we then transpose. We want the text file to be read in when we create an object from this class.

We take the ‘level’ argument and assign it to ‘self.level’ to create its own instance. ‘self.nodeLUT’ creates an empty dictionary for the lookup table. The 2 ‘symbol’ lines set the symbols, as you’d expect. We’re also storing our symbols in a list since we’ll need other symbols for other nodes and paths. The ‘data’ variable is set to read the maze file, as the method is named. It also calls ‘level’ as an argument or else it wouldn’t connect. The last 3 lines with the ‘data’ argument (that we literally just made) are the remaining steps for generating the maze.

import pygame
from vector import Vector2
from constants import *
import numpy as np

class NodeGroup(object):
    def __init__(self, level):
        self.level = level
        self.nodesLUT = {}
        self.nodeSymbols = ['+']
        self.pathSymbols = ['.']
        data = self.readMazeFile(level)
        self.createNodeTable(data)
	self.connectHorizontally(data)
	self.connectVertically(data)

This next method is the text file using NumPy’s ‘loadtxt’ function, hence the ‘np’. The dtype needs to be set to ‘<U1’ or else it will try to read in the data as floats and create an error when it encounters non-float characters like the ‘.’ character. This will return a 2D NumPy array.

def readMazeFile(self, textfile):
    return np.loadtxt(textfile, dtype='<U1')

Now we’re creating the node table as a NumPy 2D array data structure. We’ll go through it row by row, and whenever we find a ‘+’, we’ll create an entry in the lookup table with the row and column the node was found in and create a Node object. The ‘data’ argument represents the array. It’s not built-in but ‘data’ is the common name we give to structures like that. The ‘offsets’ are meant to adjust the position of the coordinates by spacing them from the margin, but since they’re set to 0, they’re moot.

We start with a ‘for’ loop that iterates over the rows in the maze array. The ‘.shape’ method after ‘data’ is a NumPy attribute that collects the dimensions of an array. The [0] after that targets the rows of the array. [1] would be the columns. The ‘data.shape’ is within a ‘range’ function which will tell us how many rows there are. The ‘list’ function converts the range to a list.

We make these 2 loops for the rows and columns. The ‘if’ statement after that checks that the values of the (row, col) position are present in the ‘self.nodeSymbols’ list; it’s looking for a node. If the values are there, it calls the ‘constructKey’ method that converts a row and column in a text file to actual pixel values on the screen by multiplying them by whatever values we set for the tile sizes.

So the dictionary keys will be a (x,y) tuple, then the values will be a Node object. We’ll pass in the (x,y) location to that Node object as well. The dictionary makes it easier to lookup a node with its (x, y) position. If we only had a list of the node objects, we’d have to loop through them just to find a specific node.

def createNodeTable(self, data, xoffset=0, yoffset=0):
    for row in list(range(data.shape[0])):
        for col in list(range(data.shape[1])):
            if data[row][col] in self.nodeSymbols:
                x, y = self.constructKey(col+xoffset, row+yoffset)
                self.nodesLUT[(x, y)] = Node(x, y)

def constructKey(self, x, y):
    return x * TILEWIDTH, y * TILEHEIGHT

Connecting Nodes Horizontally & Vertically

At this point we have a dictionary of Node objects, but none of the nodes are connected together. We’re gonna follow a 2-step process to connect them. Horizontally, then vertically.

When making the method, we use the same arguments we used in ‘createNodeTable’. Remember ‘data’ is the array of the maze symbols. The 2 ‘for’ loops do the same thing as they did in the last one: iterate through each row and column.

The ‘if’ statement checks if the current iterated position is in the ‘self.nodeSymbols’ set.

We scan each row for a ‘+’. When we find one, we check if the ‘key’ value is ‘None’ or not. We initially set it to ‘None’ when we start on a new row. The key can also contain a key to our dictionary. We call it ‘key’ so we know if 2 nodes need to be connected horizontally or not.

Again, when we come across a key, we look at the value of the key variable. If its value is ‘None’, we set it to the key of that node in the dictionary. This way we can see if it connects to another node down the line.

If we encounter a ‘+’ that is not None, but an actual value, then we connect those 2 nodes. Since we’re moving left to right, the new node we encountered is to the right of the previous node we encountered. And the previous node is to the left of the new node. Anytime we encounter any characters that are not in the ‘pathSymbols‘ list (which only contains ‘.’ for now), then set the key to ‘None‘ again.

def connectHorizontally(self, data, xoffset=0, yoffset=0):
    for row in list(range(data.shape[0])):
        key = None
        for col in list(range(data.shape[1])):
            if data[row][col] in self.nodeSymbols:
                if key is None:
                    key = self.constructKey(col+xoffset, row+yoffset)
                else:
                    otherkey = self.constructKey(col+xoffset, row+yoffset)
                    self.nodesLUT[key].neighbors[RIGHT] = self.nodesLUT[otherkey]
                    self.nodesLUT[otherkey].neighbors[LEFT] = self.nodesLUT[key]
                    key = otherkey
            elif data[row][col] not in self.pathSymbols:
                    key = None

To connect them vertically, we’re gonna transpose the array. Which means the columns become rows and the rows become columns. This way we can apply the same logic we just did to connecting the nodes vertically. The main difference here is when we connect the nodes we need to reference UP and DOWN instead of LEFT and RIGHT. If we have an array that has shape (m, n), then the shape of the transposed array is (n, m). Other than that, the code is pretty much the same.

The ‘dataT’ is the variable we’re setting for the transposed version of the array. After that, the process is the same as horizontal. Just apply ‘dataT’ where ‘data’ would be.

def connectVertically(self, data, xoffset=0, yoffset=0):
    dataT = data.transpose()
    for col in list(range(dataT.shape[0])):
        key = None
        for row in list(range(dataT.shape[1])):
            if dataT[col][row] in self.nodeSymbols:
                if key is None:
                    key = self.constructKey(col+xoffset, row+yoffset)
                else:
                    otherkey = self.constructKey(col+xoffset, row+yoffset)
                    self.nodesLUT[key].neighbors[DOWN] = self.nodesLUT[otherkey]
                    self.nodesLUT[otherkey].neighbors[UP] = self.nodesLUT[key]
                    key = otherkey
            elif dataT[col][row] not in self.pathSymbols:
                key = None

We’re also adding 2 methods that allow us to access a node through its pixel location (x, y) or its tile location (row, column).

def getNodeFromPixels(self, xpixel, ypixel):
    if (xpixel, ypixel) in self.nodesLUT.keys():
        return self.nodesLUT[(xpixel, ypixel)]
    return None

def getNodeFromTiles(self, col, row):
    x, y = self.constructKey(col, row)
    if (x, y) in self.nodesLUT.keys():
        return self.nodesLUT[(x, y)]
    return None

Next we’ll add a temporary ‘start node’ method. For now it’ll be the first node in the lookup table. We’ll change it later.

def getStartTempNode(self):
    nodes = list(self.nodesLUT.values())
    return nodes[0]

Next we have to change how to reference the nodes for drawing to the screen since we’re using the nodesLUT instead of the nodesList to keep track of our nodes.

Delete the ‘self.nodeList’ method and replace it with the LUT

def render(self, screen):
    for node in self.nodesLUT.values():
        node.render(screen)

Lastly we have to modify the ‘startGame’ method in the GameController class by passing in the name of the text file when we create the NodeGroup object. This is done in the run.py file.

Add “mazetest.txt” as an argument to the first ‘self.nodes’ line. Delete the second ‘self.nodes’. In ‘self.pacman’, delete the ‘nodeList[0]’ method, and replace that with ‘getStartTempNode()’

Then for the Pacman object we’ll call the method we just created that will return the node Pacman should start on.

def startGame(self):
    self.setBackground()
    self.nodes = NodeGroup("mazetest.txt")
    self.pacman = Pacman(self.nodes.getStartTempNode())

Maze 1

We’re gonna scrap that test maze and add in a real one that we can play on. It won’t have graphics but the layout will be there. Name it ‘maze1.txt‘

X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X + . . . . + . . . . . + X X + . . . . . + . . . . + X
X . X X X X . X X X X X . X X . X X X X X . X X X X . X
X . X X X X . X X X X X . X X . X X X X X . X X X X . X
X . X X X X . X X X X X . X X . X X X X X . X X X X . X
X + . . . . + . . + . . + . . + . . + . . + . . . . + X
X . X X X X . X X . X X X X X X X X . X X . X X X X . X
X . X X X X . X X . X X X X X X X X . X X . X X X X . X
X + . . . . + X X + . . + X X + . . + X X + . . . . + X
X X X X X X . X X X X X . X X . X X X X X . X X X X X X
X X X X X X . X X X X X . X X . X X X X X . X X X X X X
X X X X X X . X X + . . + . . + . . + X X . X X X X X X
X X X X X X . X X . X X X = = X X X . X X . X X X X X X
X X X X X X . X X . X X X X X X X X . X X . X X X X X X
+ . . . . . + . . + X X X X X X X X + . . + . . . . . +
X X X X X X . X X . X X X X X X X X . X X . X X X X X X
X X X X X X . X X . X X X X X X X X . X X . X X X X X X
X X X X X X . X X + . . . . . . . . + X X . X X X X X X
X X X X X X . X X . X X X X X X X X . X X . X X X X X X
X X X X X X . X X . X X X X X X X X . X X . X X X X X X
X + . . . . + . . + . . + X X + . . + . . + . . . . + X
X . X X X X . X X X X X . X X . X X X X X . X X X X . X
X . X X X X . X X X X X . X X . X X X X X . X X X X . X
X + . + X X + . . + . . + . . + . . + . . + X X + . + X
X X X . X X . X X . X X X X X X X X . X X . X X . X X X
X X X . X X . X X . X X X X X X X X . X X . X X . X X X
X + . + . . + X X + . . + X X + . . + X X + . . + . + X
X . X X X X X X X X X X . X X . X X X X X X X X X X . X
X . X X X X X X X X X X . X X . X X X X X X X X X X . X
X + . . . . . . . . . . + . . + . . . . . . . . . . + X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X

Go back to the ‘GameController’ class in the run.py file and change the maze file name in ‘self.nodes’.

def startGame(self):
    self.setBackground()
    self.nodes = NodeGroup("maze1.txt")
    self.pacman = Pacman(self.nodes.getStartTempNode())

At this point, Pacman has a full maze he can move through. The portals don’t yet go anywhere, so he just stops.

Portals

A signature feature of Pacman is the portals that take you from one side of the maze to the other.

To make this, we’re gonna add a new neighbor type next to our regular directional ones. This neighbor will let us jump (or portal) to it. Add ‘PORTAL’ after ‘RIGHT’ and set it to ‘None’ like the others.

class Node(object):
    def __init__(self, x, y):
        self.position = Vector2D(x, y)
        self.neighbors = {UP:None, DOWN:None, LEFT:None, RIGHT:None, PORTAL:None}

We’ll also add PORTAL to the ‘constants.py‘ file. Its value is irrelevant, so we’ll just put 3.

PORTAL = 3

Obviously, the portals have to be in pairs. Otherwise where would Pacman go? So we’re gonna create a new method in the ‘NodeGroup’ class that takes 2 tuple values that’ll check if they’re in the nodes’ LUT or not.

The 2 ‘key’ variables create a key for their respective pairs. The asterisk (*) in front of the ‘pair’ argument unpacks all the elements of ‘pair’s arguments, which is x and y. The ‘if’ statement after the keys checks if they’re present in the LUT. If they’re not, we move on. If they are, we connect them with the PORTAL key which is what the last 2 lines take care of.

def setupPortalPair(self, pair1, pair2):
    key1 = self.constructKey(*pair1)
    key2 = self.constructKey(*pair2)
    if key1 in self.nodesLUT.keys() and key2 in self.nodesLUT.keys():
        self.nodesLUT[key1].neighbors[PORTAL] = self.nodesLUT[key2]
        self.nodesLUT[key2].neighbors[PORTAL] = self.nodesLUT[key1]

In the GameController class in run.py we have to call this new method after creating the node object. 2 tuples of 2 nodes to be connected are passed in. There’s no particular reason we chose these values, we just need something in there for now.

def startGame(self):
    self.setBackground()
    self.nodes = NodeGroup("maze1.txt")
    self.nodes.setPortalPair((0,17), (27,17))
    self.pacman = Pacman(self.nodes.getStartTempNode())

Now we have to tell Pacman to jump from one node to another when going through a portal. When Pacman overshoots a node we set that node as his current node and then find the next target node. Before we try to find the next target node, we check to see if this new node is a portal node or not. If not, then we move on like normal. If it is, then we set that node’s portal node as the new node instead. In the ‘update’ method of pacman.py

def update(self, dt):	
    self.position += self.directions[self.direction]*self.speed*dt
    direction = self.getValidKey()
    if self.overshotTarget():
       self.node = self.target
           if self.node.neighbors[PORTAL] is not None:
               self.node = self.node.neighbors[PORTAL]
           self.target = self.getNewTarget(direction)
           if self.target is not self.node:
               self.direction = direction
           else:
               self.target = self.getNewTarget(self.direction)

           if self.target is self.node:
               self.direction = STOP
           self.setPosition()
       else: 
            if self.oppositeDirection(direction):
                self.reverseDirection()

Pacman can now go through a portal and come out the other with no issue

Pellets

In the original Pacman, there were 240 regular pellets plus 4 power pellets in each level. Regular is worth 10 points and power is worth 50, giving you 2600 points minimum for eating all the pellets in the level.

We’ll be following this based on our maze symbols:

• Anywhere there’s a ‘.’ or a ‘+’, place a pellet.
• Anywhere there’s a ‘p’, place a power pellet
• Anywhere there’s a ‘P’, place a power pellet

‘p’ is for a path and ‘P’ is for a node. We’ll also need symbols for areas with no pellets

1. Anywhere there’s a ‘+’, ‘P’, ‘n’, place a node
2. Anywhere there’s a ‘.’, ‘-‘, ‘|’, ‘p’, place a path

We’ll modify our maze.txt file and place pellets into it:

X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X + . . . . + . . . . . + X X + . . . . . + . . . . + X
X . X X X X . X X X X X . X X . X X X X X . X X X X . X
X p X X X X . X X X X X . X X . X X X X X . X X X X p X
X . X X X X . X X X X X . X X . X X X X X . X X X X . X
X + . . . . + . . + . . + . . + . . + . . + . . . . + X
X . X X X X . X X . X X X X X X X X . X X . X X X X . X
X . X X X X . X X . X X X X X X X X . X X . X X X X . X
X + . . . . + X X + . . + X X + . . + X X + . . . . + X
X X X X X X . X X X X X | X X | X X X X X . X X X X X X
X X X X X X . X X X X X | X X | X X X X X . X X X X X X
X X X X X X . X X n - - n - - n - - n X X . X X X X X X
X X X X X X . X X | X X X = = X X X | X X . X X X X X X
X X X X X X . X X | X X X X X X X X | X X . X X X X X X
n - - - - - + - - n X X X X X X X X n - - + - - - - - n
X X X X X X . X X | X X X X X X X X | X X . X X X X X X
X X X X X X . X X | X X X X X X X X | X X . X X X X X X
X X X X X X . X X n - - - - - - - - n X X . X X X X X X
X X X X X X . X X | X X X X X X X X | X X . X X X X X X
X X X X X X . X X | X X X X X X X X | X X . X X X X X X
X + . . . . + . . + . . + X X + . . + . . + . . . . + X
X . X X X X . X X X X X . X X . X X X X X . X X X X . X
X . X X X X . X X X X X . X X . X X X X X . X X X X . X
X P . + X X + . . + . . + . . + . . + . . + X X + . P X
X X X . X X . X X . X X X X X X X X . X X . X X . X X X
X X X . X X . X X . X X X X X X X X . X X . X X . X X X
X + . + . . + X X + . . + X X + . . + X X + . . + . + X
X . X X X X X X X X X X . X X . X X X X X X X X X X . X
X . X X X X X X X X X X . X X . X X X X X X X X X X . X
X + . . . . . . . . . . + . . + . . . . . . . . . . + X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X

Now we’re gonna create a class to deal with these pellets in a new file: pellets.py.

First, we’ll add these 2 constants in our constants.py file

PACMAN = 0
PELLET = 1
POWERPELLET = 2

Then add this to the new pellets.py file.

import pygame
from vector import Vector2
from constants import *
import numpy as np

class Pellet(object):
    def __init__(self, row, column):
        self.name = PELLET
        self.position = Vector2(column*TILEWIDTH, row*TILEHEIGHT)
        self.color = WHITE
        self.radius = int(4 * TILEWIDTH / 16)
        self.collideRadius = int(4 * TILEWIDTH / 16)
        self.points = 10
        self.visible = True
        
    def render(self, screen):
        if self.visible:
            p = self.position.asInt()
            pygame.draw.circle(screen, self.color, p, self.radius)

‘Self.position’ calculates a pellet’s position with the Vector2 object by multiplying its ‘row’ and ‘column’ parameters by their opposite tiles. A pellet is just a white circle that has a radius of 4 pixels. The ‘radius’ and the ‘collideRadius’ variables are multiplied by 4 then divided by 16 for the purpose of scaling the game based on the size of the display it’s being played on. It ensures that pellets are always a 16th of the tile. We also specify how many points a pellet is worth: 10 points. The ‘visible’ variable just allows us to hide a pellet if we want.

The ‘p’ variable in the ‘render’ method turns the pellet’s position to an integer.

The PowerPellet class defines the larger pellet that gives Pacman the special power to eat the ghosts. For now, the only difference is that it’s larger, it’s worth more points than the regular pellet, and it has a timer

The ‘flashTime’ variable makes the power pellet continually appear and disappear (hence ‘flash’) for a .2-second period. In the ‘update’ method, we first set the timer to ‘dt’ to keep track of the game time along with the power pellet’s flash time. The rest of the lines basically model the cycle of the flash.

class PowerPellet(Pellet):
    def __init__(self, row, column):
        Pellet.__init__(self, row, column)
        self.name = POWERPELLET
        self.radius = int(8 * TILEWIDTH / 16)
        self.points = 50
        self.flashTime = 0.2
        self.timer = 0
        
    def update(self, dt):
        self.timer += dt
        if self.timer >= self.flashTime:
            self.visible = not self.visible
            self.timer = 0

There’s gonna be a lot of pellets on the screen, so we should keep them organized. We won’t have to call our ‘Pellet’ and ‘PowerPellet’ classes directly, they’ll be called through this class; similar to the NodeGroup that groups all the pellets into one list.

To create a pellet, we’ll read the file line by line and create a pellet at that position based on the symbol we defined earlier. Then when we want to draw them, we just call this ‘render’ method and it will take care of drawing the pellets for us.

The ‘pelletList’ just stores all of the pellets including the power pellets, and the ‘powerpellets’ list just stores the Power Pellets. The powers have their own list so we can directly access them when creating the function to make them flash.

We’re also adding an ‘isEmpty’ method that checks for when the pelletList is empty, meaning the level has been cleared. pellets.py

class PelletGroup(object):
    def __init__(self, pelletfile):
        self.pelletList = []
        self.powerpellets = []
        self.createPelletList(pelletfile)
        self.numEaten = 0

    def update(self, dt):
        for powerpellet in self.powerpellets:
            powerpellet.update(dt)
                
    def createPelletList(self, pelletfile):
        data = self.readPelletfile(pelletfile)        
        for row in range(data.shape[0]):
            for col in range(data.shape[1]):
                if data[row][col] in ['.', '+']:
                    self.pelletList.append(Pellet(row, col))
                elif data[row][col] in ['P', 'p']:
                    pp = PowerPellet(row, col)
                    self.pelletList.append(pp)
                    self.powerpellets.append(pp)
                    
    def readPelletfile(self, textfile):
        return np.loadtxt(textfile, dtype='<U1')
    
    def isEmpty(self):
        if len(self.pelletList) == 0:
            return True
        return False
    
    def render(self, screen):
        for pellet in self.pelletList:
            pellet.render(screen)

Next we’re gonna add some node and path symbols to reflect our new maze.txt file. We’re adding ‘P’ and ‘n’ to the node, and ‘-‘, ‘/’, and ‘p’ to the path. nodes.py

class NodeGroup(object):
    def __init__(self, level):
        self.level = level
        self.nodesLUT = {}
        self.nodeSymbols = ['+', 'P', 'n']
        self.pathSymbols = ['.', '-', '|', 'p']

Now for some GameController changes. In the run.py file, we’ll import the PelletGroup class we just made.

In the ‘startGame’ method we’ll create a PelletGroup object and pass in the maze1.txt file so that it will know where to create the pellets.

In the ‘render’ method we’ll draw the pellets. Draw them before drawing Pacman so that the pellets appear below Pacman.

import pygame
...
from pellets import PelletGroup

def startGame(self):
...
    self.pellets = PelletGroup("maze1.txt")

def update(self):
...
    self.pellets.update(dt)

def render(self):
...
    self.pellets.render(self.screen)

Eating Pellets

Now that we’ve got the pellets to show, we gotta make Pacman eat them. ‘Eating’ in the technical sense means he’s colliding with the pellets. To manage this, we’ll be using a circle-to-circle collision check. Let’s say we have circles A and B. They both have their own radius, RA and RB. We also have another variable, D, the actual distance between the circles. If D is greater than the sum of the radii, then the circles can’t be colliding. If D is less than or equal to the sum, then they are colliding.

In the ‘init’ method of pacman.py, we’re going to add a variable to define Pacman’s collision radius. We could set this radius to be the same as Pacman’s but we’re gonna shrink it a bit so it looks like the pellets are being ingested and not just disappearing as soon as he touches it.

class Pacman(object):
    def __init__(self, node):
        ...
        self.collideRadius = 5

We’re also gonna create a new method that takes the pellet list and loops through each pellet until we find one that Pacman is colliding with. If we find the pellet he’s colliding with, we return it. If not, we return None.

Notice that we are comparing the square of the distances rather than the actual distances. This is to avoid taking the square root which is an expensive operation. Comparing the square of the distances is just as valid and faster.

def eatPellets(self, pelletList):
    for pellet in pelletList:
        d = self.position - pellet.position
        dSquared = d.magnitudeSquared()
        rSquared = (pellet.radius+self.collideRadius)**2
        if dSquared <= rSquared:
            return pellet
    return None

Next we’re creating a method that handles all of the pellet events. We’re sending the ‘pelletList’ to Pacman and returns the pellet (if any) that he’s colliding with. If the pellet variable is anything other than None, then we just remove that pellet from the list. This goes in the GameController class of run.py

def checkPelletEvents(self):
        pellet = self.pacman.eatPellets(self.pellets.pelletList)
        if pellet:
            self.pellets.numEaten += 1
            self.pellets.pelletList.remove(pellet)

We then call it in the ‘update’ method to bring it to life

def update(self):
...
    self.pellets.update(dt)
    self.checkPelletEvents()
    self.checkEvents()
...

At this point, the pellets are in the maze and Pacman eats them. Nothing happens when a power pellet is eaten besides it disappearing.

Ghosts Intro

As we know, there are 4 unique ghosts in Pacman. Let’s look at their movement first.

They move node to node the same way Pacman does. We have to establish some principles for their movement.

• When traveling from one node to another, they can’t reverse direction (except in a few special cases)
• When a ghost gets to a node, it can move in any direction except the one it just came from. If it moved left to get to a node, it can’t then go right
• A ghost can only backtrack if it reaches a dead end.
• Ghosts move entirely on their own. The player has 0 control.
• The ghosts choose a direction when entering a node based on which direction will get them closer to the goal they are trying to reach.

We’re gonna create a new entity.py file. Since Pacman and the ghosts move similarly, we can use this generic class to set those terms along with some more specific ones. Any object that inherits from this class will be able to move around on its own. Note the ‘visible’ variable that allows any object to be made invisible.

Most of the ‘init’ method speaks for itself. The ‘setSpeed’ method may look weird and you may be asking why are we setting the speed based on the TILEWIDTH? Well, if you have a set speed like 100, that works well for a map that has 16×16 tiles. If you make the maze bigger with 32×32 tiles, for example, then Pacman will actually appear to move slower. He’s still moving at the same speed, but he has more ground to cover on a larger maze. If you make the maze with 8×8 tiles, then he’ll appear to move twice as fast. So we need to adjust his speed depending on the size of the maze so we can get a similar experience no matter how large the maze is.

The ‘setPosition’ just matches the entity’s position to the current node’s. Just how we defined those principles for the ghosts’ movement, ‘validDirection’ checks if the direction is valid for an entity to move in; returning ‘True’ if it is and leads to a neighboring node, otherwise returning ‘False’. This leads to the ‘getNewTarget’ method since the entity needs a new target node once it’s given a new direction. ‘overshotTarget’ checks for what it is. It only has those extra lines since it’s calculating the squared distance. For the ‘reverse’ and ‘oppositeDirection’ methods, the former actually changes the entity’s movement, the latter is more for A.I. purposes where it’s just checking the opposite direction in case it may be better for its goal. We just went over ‘setSpeed’. And ‘render’, as always, does the drawing.

import pygame
from pygame.locals import *
from vector import Vector2
from constants import *
from random import randint

class Entity(object):
    def __init__(self, node):
        self.name = None
        self.directions = {UP:Vector2(0, -1),DOWN:Vector2(0, 1), 
                          LEFT:Vector2(-1, 0), RIGHT:Vector2(1, 0), STOP:Vector2()}
        self.direction = STOP
        self.setSpeed(100)
        self.radius = 10
        self.collideRadius = 5
        self.color = WHITE
        self.node = node
        self.setPosition()
        self.target = node
        self.visible = True
        self.disablePortal = False

    def setPosition(self):
        self.position = self.node.position.copy()
          
    def validDirection(self, direction):
        if direction is not STOP:
            if self.node.neighbors[direction] is not None:
                return True
        return False

    def getNewTarget(self, direction):
        if self.validDirection(direction):
            return self.node.neighbors[direction]
        return self.node

    def overshotTarget(self):
        if self.target is not None:
            vec1 = self.target.position - self.node.position
            vec2 = self.position - self.node.position
            node2Target = vec1.magnitudeSquared()
            node2Self = vec2.magnitudeSquared()
            return node2Self >= node2Target
        return False

    def reverseDirection(self):
        self.direction *= -1
        temp = self.node
        self.node = self.target
        self.target = temp
        
    def oppositeDirection(self, direction):
        if direction is not STOP:
            if direction == self.direction * -1:
                return True
        return False

    def setSpeed(self, speed):
        self.speed = speed * TILEWIDTH / 16

    def render(self, screen):
        if self.visible:
            p = self.position.asInt()
            pygame.draw.circle(screen, self.color, p, self.radius)

After that we’re gonna add an ‘update’ method to this class. It’s mostly similar to Pacman’s, except that we’re not choosing the ghosts’ direction. Instead, we’ll make them choose a random next direction when they get to a node.

Like any ‘update’ method, this updates the object’s state as time goes on; hence the ‘dt’ argument to represent time. The ‘self.position’ below that makes the entity move at a constant speed over time. The big ‘if’ statement checks if the entity overshot its target. If it did, per the next 3 lines, its current node is set to be the target, it retrieves the list of valid directions, then it calls to select a random direction.

The ‘if not’ statement deals with portals. Checking if they’re enabled and if the current node has a neighbor connected through a portal. If both conditions are met, the entity’s current node is updated to the neighboring node connected through the portal.

‘getNewTarget’ does what it says. The last ‘if’ statement updates the entity’s direction once the new target is chosen. Assuming the target is different from the current node. Otherwise, if the target is the same as the current, ‘self.direction’ is restricted from changing. Then finally, the entity’s position is updated to the new current node.

def update(self, dt):
    self.position += self.directions[self.direction]*self.speed*dt
         
    if self.overshotTarget():
        self.node = self.target
        directions = self.validDirections()
        direction = self.randomDirection(directions)   
        if not self.disablePortal:
            if self.node.neighbors[PORTAL] is not None:
                self.node = self.node.neighbors[PORTAL]
            self.target = self.getNewTarget(direction)
            if self.target is not self.node:
                self.direction = direction
            else:
                self.target = self.getNewTarget(self.direction)

            self.setPosition()

The ‘validDirections’ method is different from ‘validDirection’ in pacman.py. The former contains a list of valid directions the entity can move in. We use the ‘directions’ variable to initialize an empty list. We’ll loop through all 4 directions and see if the node connects to another node in that direction. If it does, then we make sure it’s not the node we’re coming from. If the list is still empty after those loops, then we stick with the direction from which we came. We add that as the only valid direction.

The second method just chooses one of the directions randomly using the ‘randint’ method we imported.

def validDirections(self):
        directions = []
        for key in [UP, DOWN, LEFT, RIGHT]:
            if self.validDirection(key):
                if key != self.direction * -1:
                    directions.append(key)
        if len(directions) == 0:
            directions.append(self.direction * -1)
        return directions

def randomDirection(self, directions):
    return directions[randint(0, len(directions)-1)]

Now we gotta add Pacman in as an entity too. This is done in pacman.py

We first import ‘entity’. We change the Pacman class’s inheritance to ‘Entity’. Since we added those generic characteristics in the entity.py file, we can delete them from Pacman so he only has those specific to him. So we’ll delete the methods ‘setPosition’, ‘overshotTarget’, ‘valid/reverse/oppositeDirection’, and the ‘render’ method. Again, these are already in entity.py so it’s redundant to have them in pacman.py too. Also add an ‘Entity.__init__’ line right under Pacman’s ‘init’ method.

import pygame
...
from entity import Entity

class Pacman(Entity):
    def __init__(self, node):
        Entity.__init__(self, node)
        self.name = PACMAN
        ...

Nothing should be different about the game at this point. If it is, you did something wrong

Ghost Setup

Now we’re gonna create a new file ghosts.py. And we’re gonna add a ‘ghosts’ constant with a value of 3.

GHOST = 3

Create a ‘Ghost’ class with an inheritance from ‘Entity’. Start the ‘init’ method with an ‘entity init’, setting ‘self’ and ‘node’ as both of their arguments. Write the name and set the points to 200.

import pygame
from pygame.locals import *
from vector import Vector2
from constants import *
from entity import Entity

class Ghost(Entity):
    def __init__(self, node):
        Entity.__init__(self, node)
        self.name = GHOST
        self.points = 200

We’ll also make our additions in the run.py file. We do the import, and add to the ‘startGame’, ‘update’, and ‘render’ methods.

import pygame
...
from ghosts import Ghost

def startGame(self):
...
    self.ghost = Ghost(self.nodes.getStartTempNode())

def update(self):
...
    self.pacman.update(dt)
    self.ghost.update(dt)

def render(self):
...
    self.ghost.render(self.screen)
    pygame.display.update()

At this point, there is one ghost moving randomly around the maze. Nothing happens if Pacman collides with it

Ghost AI Start

At this point the ghosts are moving randomly around the maze. To make the game a challenge we can give them some intelligence, or at least the appearance of such. We can do this by simply giving them a goal to reach (a vector), and they never have to reach it.

We add a goal vector in the entity.py and the ghosts.py files. Entity’s is set to ‘None’ since that would give all entities the same goal. We just want to work with the ghosts, so we set that in the ghost’s file to specify it.

class Entity(object):
    def __init__(self, node):
        ...
       self.goal = None

---SEPARATE FILE---

class Ghost(Entity):
    def __init__(self, node):
       ...
        self.goal = Vector2()

This next method will take a list of directions, we’ll assume they are already valid directions, and for each of the directions in the list it will calculate the distance from the entity to the goal. It then returns the direction with the smallest distance; specifically the line of sight distance.

What you should see after you implement these changes is that the ghost will be moving around in a circle in the upper left corner. This is because the ghost is basically trying to reach the screen’s origin which is the upper left corner of the screen, but can’t because of the movement restrictions we’ve placed on it. Remember that it can’t ever STOP during the game, so it has to choose a target every time it reaches a node, even if that target takes it further from the goal. But if it is able to choose a target that takes it closer to the goal, it will. In entity.py

def goalDirection(self, directions):
        distances = []
        for direction in directions:
            vec = self.node.position  + self.directions[direction]*TILEWIDTH - self.goal
            distances.append(vec.magnitudeSquared())
        index = distances.index(min(distances))
        return directions[index]

So for an entity that needs to reach its goal, it’ll call this ‘self.directionMethod’ instead of the ‘randomDirection’ method. It’ll be a variable that replaces it. Also, delete the ‘direction’ variable and replace ‘randomDirection’ with ‘directionMethod’

class Entity(object):
    def __init__(self, node):
        ...
        self.directionMethod = self.randomDirection

def update(self, dt):
        self.position += self.directions[self.direction]*self.speed*dt
         
        if self.overshotTarget():
            self.node = self.target
            directions = self.validDirections()
            direction = self.directionMethod(directions)
            if not self.disablePortal:
                if self.node.neighbors[PORTAL] is not None:
                    self.node = self.node.neighbors[PORTAL]
            self.target = self.getNewTarget(direction)
            if self.target is not self.node:
                self.direction = direction
            else:
                self.target = self.getNewTarget(self.direction)

            self.setPosition()

After establishing that, we just tell the ghost to use the new method instead of ‘randomDirections’ in ghosts.py

class Ghost(Entity):
    def __init__(self, node):
...
        self.directionMethod = self.goalDirection

The ghost should circle the top left corner at this point.

Modes Overview

Technically, all the phases of the game are based around the ghosts’ behavior. For that, there are 4 modes:

1. Chase – the default phase, a ghost is tracking down Pacman; his position is their goal. Different methods for all ghosts
2. Freight – when Pacman eats a power pellet, the ghosts are vulnerable and move randomly and slowly. This lasts longer in earlier levels and shorter in the later ones.
3. Scatter -a ghost scatters to the corner of the maze. Each ghost has his own corner
4. Spawn – when Pacman eats the ghosts. Their goal is to get to their spawn location to respawn. They move very fast in this mode.

We can think of chase and scatter to be the main modes and the others to be transitional. All the ghosts should be synchronized to scatter and chase at the same time. There should be an object to continuously flip these back & forth independent of what the ghosts are doing. The ghosts can individually go into one of the interrupt modes, but once those are finished they can easily find out if they should be in SCATTER or CHASE by asking the main mode object. 

We’ll add each of the 4 modes to the constants.py file, numbered 0 to 3 for their values.

SCATTER = 0
CHASE = 1
FREIGHT = 2
SPAWN = 3

We’re creating another file called mode.py. Scatter mode has a timer set to it so that when it runs out, it switches to chase mode for however long we set it.

from constants import *

class MainMode(object):
    def __init__(self):
        self.timer = 0
        self.scatter()

    def update(self, dt):
        self.timer += dt
        if self.timer >= self.time:
            if self.mode is SCATTER:
                self.chase()
            elif self.mode is CHASE:
                self.scatter()

    def scatter(self):
        self.mode = SCATTER
        self.time = 7
        self.timer = 0

    def chase(self):
        self.mode = CHASE
        self.time = 20
        self.timer = 0

In this file we’re going to create a class that controls the modes so that we can always know which mode the ghost has to be in. Right now it’s only passing along the main mode (scatter or chase).

We’ll also pass in the entity this mode controller is controlling in case it needs to send any messages back to the entity.

class ModeController(object):
    def __init__(self, entity):
        self.timer = 0
        self.time = None
        self.mainmode = MainMode()
        self.current = self.mainmode.mode
        self.entity = entity 

    def update(self, dt):
        self.mainmode.update(dt)
        self.current = self.mainmode.mode

Now we gotta make the ghosts aware of this mode class. As far as they’re concerned, the only difference between the modes is what their goal (target node) is. As of now, the one ghost’s only goal is scatter, which is defined to the upper-left corner. And since the goal in chase mode is Pacman’s position, we’ll have to make the ghost aware of that.

We first add the import in the ghosts.py file. Then update the ‘init’ method in the Ghost class. Along with the node the ghost should start on, we’ll pass in the Pacman and mode objects. We’ll also create scatter and chase methods so we can replace our goal with the output of the scatter method.

...
from modes import ModeController

class Ghost(Entity):
    def __init__(self, node, pacman=None):
...
        self.pacman = pacman
        self.mode = ModeController(self)

We see the scatter and chase methods simply define the ghosts’ goal. Scatter’s is the top-left corner and chase’s is Pacman’s position. In this update method, we’re asking it which mode it’s in. Then we call the parent’s update method at the end.

def update(self, dt):
        self.mode.update(dt)
        if self.mode.current is SCATTER:
            self.scatter()
        elif self.mode.current is CHASE:
            self.chase()
        Entity.update(self, dt)

    def scatter(self):
        self.goal = Vector2()

    def chase(self):
        self.goal = self.pacman.position

Then in the run.py file, we pass in the Pacman object to the ghost so he can keep track of where Pacman is.

def startGame(self):
    ...
    self.ghost = Ghost(self.nodes.getStartTempNode(), self.pacman)

At this point the ghost should start moving in the top-left corner as before, then eventually start chasing Pacman. Still nothing happens when they collide

Ghost Home

You know what this is. This is where the ghosts start and respawn. Pacman isn’t ever allowed to go in here. Once the game starts, the ghosts don’t come back here unless they’re eaten.

To make the nodes for this, we’re gonna create a new method ‘createHomeNodes’ which will need an x-offset and y-offset. We add this into nodes.py

class NodeGroup(object):
    def __init__(self, level):
        ...
       self.homekey = None

Since the home is so small, we can put the symbols directly in the code instead of a text file.

def createHomeNodes(self, xoffset, yoffset):
        homedata = np.array([['X','X','+','X','X'],
                             ['X','X','.','X','X'],
                             ['+','X','.','X','+'],
                             ['+','.','+','.','+'],
                             ['+','X','X','X','+']])

        self.createNodeTable(homedata, xoffset, yoffset)
        self.connectHorizontally(homedata, xoffset, yoffset)
        self.connectVertically(homedata, xoffset, yoffset)
        self.homekey = self.constructKey(xoffset+2, yoffset)
        return self.homekey

The nodes of this box have to be other nodes, otherwise the ghosts can’t enter or exit. Pacman should never enter, but the ghosts will need to in spawn mode.

This method connects the topmost node to whatever other node we want. We also need to specify a direction. For example, let’s say there’s a node to the right of the home node that we want to connect to. I need to specify the key to that node and also the RIGHT direction. This will connect the two nodes together in both directions. So the home node will connect to the other node on the LEFT. This will overwrite what was previously in the other nodes’ LEFT value.

def connectHomeNodes(self, homekey, otherkey, direction):     
    key = self.constructKey(*otherkey)
    self.nodesLUT[homekey].neighbors[direction] = self.nodesLUT[key]
    self.nodesLUT[key].neighbors[direction*-1] = self.nodesLUT[homekey]

In the ‘startGame’ method of the run.py file we’ll add 3 lines to code the home box into actual nodes. We call the ‘connectHomeNodes’ method twice so the home is connected to a node to its left and right.

def startGame(self):
    self.nodes.setPortalPair((0,17), (27,17))
    homekey = self.nodes.createHomeNodes(11.5, 14)
    self.nodes.connectHomeNodes(homekey, (12,14), LEFT)
    self.nodes.connectHomeNodes(homekey, (15,14), RIGHT)
    self.pacman = Pacman(self.nodes.getStartTempNode())

At this point, the home box is now an open space that Pacman and the ghosts are able to come and go into. We’ll add the restrictions later

Freight Mode

This is the iconic mode that makes the game what it is. Pacman has to be able to eat the ghosts, and the ghosts have to be able to respawn.

The ghosts are currently either in chase or scatter mode. Freight mode can only happen 4 times in a level since there are only 4 power pellets. It only lasts for about 7 seconds, decreasing the time with each level. The ghosts also move 50% their speed in freight mode.

This section will only send the ghosts in freight mode. We’ll need another section to break down eating them.

We’re gonna modify the ‘checkPelletEvents’ method in run.py to ask if it was a power pellet that was eaten.

def checkPelletEvents(self):
    pellet = self.pacman.eatPellets(self.pellets.pelletList)
    if pellet:
        self.pellets.numEaten += 1
        self.pellets.pelletList.remove(pellet)
        if pellet.name == POWERPELLET:
           self.ghost.startFreight()

Now we’re gonna set the method for freight mode in the ‘ModeController’ class in modes.py.

class ModeController(object):
   def setFreightMode(self):
        if self.current in [SCATTER, CHASE]:
            self.timer = 0
            self.time = 7
            self.current = FREIGHT
        elif self.current is FREIGHT:
            self.timer = 0

Then we modify the update method to keep track of how long we’re in freight mode.

def update(self, dt):
    self.mainmode.update(dt)
    if self.current is FREIGHT:
        self.timer += dt
        if self.timer >= self.time:
            self.time = None
            self.entity.normalMode()
            self.current = self.mainmode.mode
    else:
        self.current = self.mainmode.mode

We add these 2 methods to ghosts.py. As you can see they mainly control the speed of the ghosts when they’re in freight mode.

def startFreight(self):
    self.mode.setFreightMode()
    if self.mode.current == FREIGHT:
        self.setSpeed(50)
        self.directionMethod = self.randomDirection         

def normalMode(self):
    self.setSpeed(100)
    self.directionMethod = self.goalDirection

At this point, the ghost will slow to half its speed for 7 seconds when Pacman eats a power pellet. Nothing happens if they collide

Spawn Mode

After Pacman eats a ghost, it’ll have to travel its speed multiplied back to the spawn point. So we’ll set a spawn goal in the middle of that box.

We add this to the ‘startGame’ method in run.py.

def startGame(self):
...
    self.ghost.setSpawnNode(self.nodes.getNodeFromTiles(2+11.5, 3+14))

‘setSpawnMode’ defines the node we want to use. ‘spawn’ sets the location.

We add these next 3 methods in ghosts.py. The ‘startSpawn’ method is similar to ‘startFreight’ in that it checks to make sure we can start the SPAWN mode, and if so we increase the ghost’s speed, set the goal for the spawn location, and set the ‘directionMethod’ since before, the ghost was in FREIGHT mode and moving around randomly.

def spawn(self):
    self.goal = self.spawnNode.position

def setSpawnNode(self, node):
    self.spawnNode = node

def startSpawn(self):
    self.mode.setSpawnMode()
    if self.mode.current == SPAWN:
        self.setSpeed(150)
        self.directionMethod = self.goalDirection
        self.spawn()

We’ll create a new method here that will set the current mode to SPAWN only if the ghost is in FREIGHT mode.

In the ‘update’ method in modes.py file, we’ll need to check to see when the ghost reaches the home so we can change his mode back. Remove the ‘else’ and replace it with the ‘elif’ statement as shown.

def update(self, dt):
...
    elif self.current in [SCATTER, CHASE]:
        self.current = self.mainmode.mode

    if self.current is SPAWN:
        if self.entity.node == self.entity.spawnNode:
            self.entity.normalMode()
            self.current = self.mainmode.mode

def setSpawnMode(self):
    if self.current is FREIGHT:
       self.current = SPAWN

Now for the ultimate point function, checking if Pacman has collided with a ghost. In pacman.py, we’re gonna create a method similar to the pellet collision one. Delete the 4 lines between the ‘for’ and ‘return’ statements in the ‘eatPellets’ method.

def eatPellets(self, pelletList):
    for pellet in pelletList:
        if self.collideCheck(pellet):
           return pellet
    return None    

def collideGhost(self, ghost):
    return self.collideCheck(ghost)

def collideCheck(self, other):
    d = self.position - other.position
    dSquared = d.magnitudeSquared()
    rSquared = (self.collideRadius + other.collideRadius)**2
    if dSquared <= rSquared:
        return True
    return False

Next we create a method in run.py that checks certain ghost events. Here we’ll see if Pacman has collided with the ghost, and if so we’ll check to see if the ghost is in FREIGHT mode. If he is, then we start his spawn mode. If he’s not, then Pacman dies.

When running, eat a power pellet then collide with the ghost and you’ll see that he’ll quickly rush off to the middle of the screen. When he gets there he will go back to normal.

def update(self):
...
    self.checkGhostEvents()
    self.checkEvents()
    self.render()

def checkGhostEvents(self):
    if self.pacman.collideGhost(self.ghost):
        if self.ghost.mode.current is FREIGHT:
           self.ghost.startSpawn()

At this point, when Pacman eats a ghost, the ghost will scatter to the home box and default to chase mode

The Ghosts

The 4 ghosts are Blinky, Pinky, Inky, and Clyde. Their colors are red, pink, teal, and orange in that order.

Add this to the constants.py file

PINK = (255,100,150)
TEAL = (100,255,255)
ORANGE = (230,190,40)

...
BLINKY = 4
PINKY = 5
INKY = 6
CLYDE = 7

And now we’re gonna make the ghost classes in ghost.py. Starting with Blinky

class Ghost(Entity):
    def __init__(self, node, pacman=None, blinky=None):
...
        self.blinky = blinky
        self.homeNode = node

class Blinky(Ghost):
    def __init__(self, node, pacman=None, blinky=None):
        Ghost.__init__(self, node, pacman, blinky)
        self.name = BLINKY
        self.color = RED

Unlike Blinky who simply chases Pacman, Pinky tried to hit him head-on. It does this by identifying Pacman’s position and targeting 4 tiles ahead of him.

class Pinky(Ghost):
    def __init__(self, node, pacman=None, blinky=None):
        Ghost.__init__(self, node, pacman, blinky)
        self.name = PINKY
        self.color = PINK

    def scatter(self):
        self.goal = Vector2(TILEWIDTH*NCOLS, 0)

    def chase(self):
        self.goal = self.pacman.position + self.pacman.directions[self.pacman.direction] * TILEWIDTH * 4

Inky does the same thing but a little more precise. He targets 2 tiles ahead of Pacman’s position, subtract Blinky’s position, then multiply the result by 2.

class Inky(Ghost):
    def __init__(self, node, pacman=None, blinky=None):
        Ghost.__init__(self, node, pacman, blinky)
        self.name = INKY
        self.color = TEAL

    def scatter(self):
        self.goal = Vector2(TILEWIDTH*NCOLS, TILEHEIGHT*NROWS)

    def chase(self):
        vec1 = self.pacman.position + self.pacman.directions[self.pacman.direction] * TILEWIDTH * 2
        vec2 = (vec1 - self.blinky.position) * 2
        self.goal = self.blinky.position + vec2 

Clyde is more random. If he’s less than 8 tiles away from Pacman, he retreats to his scatter goal in the bottom left corner. If he’s far away enough, he acts like Pinky.

class Clyde(Ghost):
    def __init__(self, node, pacman=None, blinky=None):
        Ghost.__init__(self, node, pacman, blinky)
        self.name = CLYDE
        self.color = ORANGE

    def scatter(self):
        self.goal = Vector2(0, TILEHEIGHT*NROWS)

    def chase(self):
        d = self.pacman.position - self.position
        ds = d.magnitudeSquared()
        if ds <= (TILEWIDTH * 8)**2:
            self.scatter()
        else:
            self.goal = self.pacman.position + self.pacman.directions[self.pacman.direction] * TILEWIDTH * 4

We’ll deal with the ghosts as a group rather than individually.

We’ll store all the ghost objects in a list. The ‘__iter__’ method allows us to loop through the ghost list in a convenient fashion.

So in all of these methods, we just loop through the ghosts list and perform the action on each ghost. Notice the ‘updatePoints’ and ‘resetPoints’ methods. So when Pacman eats a ghost he gets 200 points, when he eats the second ghost he gets 400 points, then 800 points, and finally 1600 points. Basically, the points a ghost is worth doubles every time he eats one. When Pacman eats a new power pellet those points reset back to 200. So to maximize your score you want to eat all of the ghosts for each of the 4 power pellets.

class GhostGroup(object):
    def __init__(self, node, pacman):
        self.blinky = Blinky(node, pacman)
        self.pinky = Pinky(node, pacman)
        self.inky = Inky(node, pacman, self.blinky)
        self.clyde = Clyde(node, pacman)
        self.ghosts = [self.blinky, self.pinky, self.inky, self.clyde]

    def __iter__(self):
        return iter(self.ghosts)

    def update(self, dt):
        for ghost in self:
            ghost.update(dt)

    def startFreight(self):
        for ghost in self:
            ghost.startFreight()
        self.resetPoints()

    def setSpawnNode(self, node):
        for ghost in self:
            ghost.setSpawnNode(node)

    def updatePoints(self):
        for ghost in self:
            ghost.points *= 2

    def resetPoints(self):
        for ghost in self:
            ghost.points = 200

    def reset(self):
        for ghost in self:
            ghost.reset()

    def hide(self):
        for ghost in self:
            ghost.visible = False

    def show(self):
        for ghost in self:
            ghost.visible = True

    def render(self, screen):
        for ghost in self:
            ghost.render(screen)

In run.py, we’re gonna run the GhostGroup class instead of just Ghost. Any method that says ‘ghost’ we change it to ‘ghosts’. Also, change the ‘Ghost’ import to ‘GhostGroup’. Also, delete the 3 lines in ‘checkGhostEvents’ and replace it with the 4 shown

from ghosts import GhostGroup

    def startGame(self):
    ...
        self.ghosts = GhostGroup(self.nodes.getStartTempNode(), self.pacman      
        self.ghosts.setSpawnNode(self.nodes.getNodeFromTiles(2+11.5, 3+14))

    def update(self):
        self.pacman.update(dt)
        self.ghosts.update(dt)
    
    def checkPelletEvents(self):
    ...
         self.ghosts.startFreight()

    def checkGhostEvents(self):
        for ghost in self.ghosts:
            if self.pacman.collideGhost(ghost):
                if ghost.mode.current is FREIGHT:
                    ghost.startSpawn()

    def render(self):
    ...
        self.ghosts.render(self.screen)
            pygame.display.update()

At this point, there are 4 ghosts with their own colors and movement patterns. They still scatter back to the home box when eaten.

Start Positions

Pacman starts below the ghost home. Not directly on a node, but between 2 nodes. Blinky starts directly above the ghost home, outside of it. Pinky starts below Blinky in the ghost home. Inky starts to the left of Pinky, and Clyde starts to the right of Pinky.

We pass in the nodes in the ‘startGame’ method in the run.py file. The ‘self.pacman’ replaces the one that’s already there

• Pacman: Starts between nodes at (12,26) and (15, 26)
• Blinky: Starts on node at (2, 0) of the homedata array. Remember for all of the ghosts we have to add the offset values of (11.5, 14). So Blinky’s node is really at (2, 0) + (11.5, 14) = (13.5, 14)
• Pinky: Starts on node at (2, 3) of the homedata array. Remember for all of the ghosts we have to add the offset values of (11.5, 14). So Pinky’s node is really at (2, 3) + (11.5, 14) = (13.5, 17)
• Inky: Starts on node at (0, 3) of the homedata array. Remember for all of the ghosts we have to add the offset values of (11.5, 14). So Inky’s node is really at (0, 3) + (11.5, 14) = (11.5, 17)
• Clyde: Starts on node at (4, 3) of the homedata array. Remember for all of the ghosts we have to add the offset values of (11.5, 14). So Clyde’s node is really at (4, 3) + (11.5, 14) = (15.5, 17)

First, in the ‘self.pacman’ line, we’re gonna replace the ‘getStartTempNode’ with ‘getNodeFromTiles’ and the node values after that. Then we add a line for each ghost in between the last 2 ‘self.ghosts’ lines.

def startGame(self):
...
    self.pacman = Pacman(self.nodes.getNodeFromTiles(15, 26))
    self.pellets = PelletGroup("maze1.txt")
    self.ghosts = GhostGroup(self.nodes.getStartTempNode(), self.pacman)                     self.ghosts.blinky.setStartNode(self.nodes.getNodeFromTiles(2+11.5, 0+14))
        self.ghosts.pinky.setStartNode(self.nodes.getNodeFromTiles(2+11.5, 3+14))
        self.ghosts.inky.setStartNode(self.nodes.getNodeFromTiles(0+11.5, 3+14))
        self.ghosts.clyde.setStartNode(self.nodes.getNodeFromTiles(4+11.5, 3+14))
        self.ghosts.setSpawnNode(self.nodes.getNodeFromTiles(2+11.5, 3+14)

Next in entity.py, we modify it to set it to ‘node’ and ‘target’ and then call the ‘setPosition’ method. We’re deleting the 3 lines from ‘self.node’ to ‘self.target’.

class Entity(object):
    def __init__(self, node):
...
        self.directionMethod = self.randomDirection
        self.setStartNode(node)

    def setStartNode(self, node):
        self.node = node
        self.startNode = node
        self.target = node
        self.setPosition()

Next we’re gonna make Pacman move at the start of the game. As of now he’ll just be stationary on that first node. We add this to pacman.py

class Pacman(object):
    def __init__(self, node):
...
        self.color = YELLOW
        self.direction = LEFT

At this point, Pacman and the ghosts all start on their assigned nodes. Blinky and Pinky start moving right off the bat. Inky and Clyde circle around in the ghost home before finally coming out. Before adding that ‘self.direction’ line in the init of pacman.py, he’s still. With it, he starts moving off the bat too.

Fruit

This is simple. The fruit appears at the middle of the board below the ghost home. If Pacman doesn’t collide with it before the timer runs out, the fruit disappears. In Ms. Pacman, the fruit moves around, but we’ll keep it still for this game.

We’ll add green in RGB and fruit = 8 to constants.py.

...
GREEN = (0, 255, 0)
...
PACMAN = 0
PELLET = 1
POWERPELLET = 2
GHOST = 3
BLINKY = 4
PINKY = 5
INKY = 6
CLYDE = 7
FRUIT = 8

Now we’re gonna create a new file of fruit.py. The fruit will appear between 2 nodes and only last 5 seconds.

import pygame
from entity import Entity
from constants import *

class Fruit(Entity):
    def __init__(self, node):
        Entity.__init__(self, node)
        self.name = FRUIT
        self.color = GREEN
        self.lifespan = 5
        self.timer = 0
        self.destroy = False
        self.points = 100
        self.setBetweenNodes(RIGHT)

    def update(self, dt):
        self.timer += dt
        if self.timer >= self.lifespan:
            self.destroy = True

This next code is for setting any entity between 2 nodes in entity.py.

def setBetweenNodes(self, direction):
    if self.node.neighbors[direction] is not None:
        self.target = self.node.neighbors[direction]
        self.position = (self.node.position + self.target.position) / 2.0

For Pacman starting between nodes, we add this line to pacman.py

class Pacman(Entity):
    def __init__(self, node):
    ...
        self.direction = LEFT
        self.setBetweenNodes(LEFT)

Then we make our changes to the Gamecontroller in run.py

from fruit import Fruit

class GameController(object):
    def __init__(self):
...
        self.fruit = None

    def update(self):
    ...
        self.pellets.update(dt)
            if self.fruit is not None:
                self.fruit.update(dt)
        self.checkPelletEvents()
        self.checkGhostEvents()
        self.checkFruitEvents()
        self.checkEvents()

    def checkFruitEvents(self):
        if self.pellets.numEaten == 50 or self.pellets.numEaten == 140:
            if self.fruit is None:
                self.fruit = Fruit(self.nodes.getNodeFromTiles(9, 20))
        if self.fruit is not None:
            if self.pacman.collideCheck(self.fruit):
                self.fruit = None
            elif self.fruit.destroy:
                self.fruit = None
   
   def render(self):
   ...
       self.pellets.render(self.screen)
       if self.fruit is not None:
           self.fruit.render(self.screen)
       self.pacman.render(self.screen)
   ...

We now have the mechanics for the fruit in place, but we’ll have to add the actual fruit later on.

Pausing

There are 5 events that pause the game

1. Pressing the space bar. If the game is already paused, then this unpauses it. This will be a switch.
2. Pacman eats a ghost. The game pauses for a little bit when this happens. It may look like a glitch.
3. Game is paused at the start of a level. Similar to #1
4. Level complete
5. Pacman’s death

We’re creating a new pauser.py file.

class Pause(object):
    def __init__(self, paused=False):
        self.paused = paused
        self.timer = 0
        self.pauseTime = None
        self.func = None
        
    def update(self, dt):
        if self.pauseTime is not None:
            self.timer += dt
            if self.timer >= self.pauseTime:
                self.timer = 0
                self.paused = False
                self.pauseTime = None
                return self.func
        return None

    def setPause(self, playerPaused=False, pauseTime=None, func=None):
        self.timer = 0
        self.func = func
        self.pauseTime = pauseTime
        self.flip()

    def flip(self):
        self.paused = not self.paused

And then we modify the Gamecontroller in run.py

from pauser import Pause

class GameController(object):
    def __init__(self):
        ...
        self.pause = Pause(True)

    def update(self):
        self.pellets.update(dt)
        if not self.pause.paused:
            self.pacman.update(dt)
            self.ghosts.update(dt)
...
        self.checkFruitEvents()
        afterPauseMethod = self.pause.update(dt)
        if afterPauseMethod is not None:
            afterPauseMethod()
        self.checkEvents()  

Next we add to the ‘checkEvents’ method to check if the user has pressed the spacebar.

def checkEvents(self):
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()
        elif event.type == KEYDOWN:
            if event.key == K_SPACE:
                self.pause.setPause(playerPaused=True)
                if not self.pause.paused:
                    self.showEntities()
                else:
                    self.hideEntities()

These next 2 events will un/hide entities when we need to.

def checkGhostEvents(self):
...
            if ghost.mode.current is FREIGHT:
                self.pacman.visible = False
                ghost.visible = False
                self.pause.setPause(pauseTime=1, func=self.showEntities)
                ghost.startSpawn()

def showEntities(self):
    self.pacman.visible = True
    self.ghosts.show()

def hideEntities(self):
    self.pacman.visible = False
    self.ghosts.hide()

At this point, the game is paused when you run it. It won’t start until you press the spacebar. If you press it during the game, it’ll pause, and the entities disappear while it’s paused. These are the only 2 events that pause the game as of now.

Level Advancing

Up to this point, nothing happens when Pacman eats all the pellets. This is telling the game what to do when all the pellets are gone. In run.py

class GameController(object):
    def __init__(self):
        ...
        self.level = 0

    def nextLevel(self):
        self.level += 1
        self.pause.paused = True
        self.startGame()

Next in the ‘checkPelletEvents’ and ‘nextLevel’ methods, we’ll set the game to pause 3 secs when the last pellet is eaten.

def checkPelletEvents(self):
...
        if self.pellets.isEmpty():
            self.hideEntities()
            self.pause.setPause(pauseTime=3, func=self.nextLevel)

def nextLevel(self):
    self.showEntities()
    ...

At this point, when all the pellets are eaten, the game will reset and bring them back. There is also a brief pause when Pacman eats a ghost.

Death to Pacman

Pacman dying means 4 things

1. When he dies, the game pauses for 3 secs
2. The level needs to reset, except for the pellets
3. We have to give him some lights
4. If all lives are lost, the game is over

Here’s the code to give him some lives in run.py

class GameController(object):
    def __init__(self):
        ...
        self.lives = 5

    def restartGame(self):
        self.lives = 5
        self.level = 0
        self.pause.paused = True
        self.fruit = None
        self.startGame()

    def resetLevel(self):
        self.pause.paused = True
        self.pacman.reset()
        self.ghosts.reset()
        self.fruit = None

We don’t need to start the whole level over, just reset Pacman’s position and a few other variables. Like the ghosts. In entity.py

def reset(self):
        self.setStartNode(self.startNode)
        self.direction = STOP
        self.speed = 100
        self.visible = True

For Pacman, we override the basic reset method from the Entity class and add a couple more things. We need to set Pacman’s initial direction to LEFT and place him between the 2 nodes discussed previously. In pacman.py

class Pacman(Entity):
    def __init__(self, node):
        ...
        self.alive = True
    
    def reset(self):
        Entity.reset(self)
        self.direction = LEFT
        self.setBetweenNodes(LEFT)
        self.alive = True

    def die(self):
        self.alive = False
        self.direction = STOP

This is for resetting ghosts. In ghosts.py

def reset(self):
    Entity.reset(self)
    self.points = 200
    self.directionMethod = self.goalDirection

Next in run.py we check if Pacman has collided with a ghost. If it’s not in spawn mode, then Pacman is killed. His lives are reduced by 1 then we check if he has any more lives left. If he does, we reset the game. If he doesn’t, we restart it. Either way, the game will pause 3 seconds during this operation.

def checkGhostEvents(self):
...
                ghost.startSpawn()
            elif ghost.mode.current is not SPAWN:
                if self.pacman.alive:
                    self.lives -=  1
                    self.pacman.die()
                    self.ghosts.hide()
                    if self.lives <= 0:
                        self.pause.setPause(pauseTime=3, func=self.restartGame)
                    else:
                        self.pause.setPause(pauseTime=3, func=self.resetLevel)

Lastly we’re gonna add a line to the ‘checkEvents’ method in run.py to make sure we can’t pause while Pacman is dying

def checkEvents(self):
...
                if event.key == K_SPACE:
                    if self.pacman.alive:
                        self.pause.setPause(playerPaused=True)
...

An error returns when Pacman collides with a ghost. I don’t feel like dealing with it, so this is the main game-breaking bug I’m gonna leave in.

Node Restrictions

Once a ghost runs home after it’s eaten, it goes back to either scatter or chase mode. There’s a glitch where it can get stuck inside the home when it’s in chase mode and Pacman is directly below the home. There’s only 1 exit out of the home and that’s up. Pacman is also able to enter the home and ghosts are too outside of spawn mode. We have to restrict them from entering this region while allowing them to under certain conditions.

In nodes.py we add a dictionary and 2 new methods. One to allow access and one to deny it.

def __init__(self, x, y):
...
    self.access = {UP:[PACMAN, BLINKY, PINKY, INKY, CLYDE, FRUIT],
                       DOWN:[PACMAN, BLINKY, PINKY, INKY, CLYDE, FRUIT],
                       LEFT:[PACMAN, BLINKY, PINKY, INKY, CLYDE, FRUIT],
                       RIGHT:[PACMAN, BLINKY, PINKY, INKY, CLYDE, FRUIT]}

def denyAccess(self, direction, entity):
    if entity.name in self.access[direction]:
            self.access[direction].remove(entity.name)

def allowAccess(self, direction, entity):
    if entity.name not in self.access[direction]:
        self.access[direction].append(entity.name)

In entity.py, we’re gonna add a line to check if a entity has access to move in a certain direction on a node.

def validDirection(self, direction):
        if direction is not STOP:
            if self.name in self.node.access[direction]:
                if self.node.neighbors[direction] is not None:

Next we add some more methods to nodes.py to restrict/allow access to a node’s direction

def denyAccess(self, col, row, direction, entity):
        node = self.getNodeFromTiles(col, row)
        if node is not None:
            node.denyAccess(direction, entity)

    def allowAccess(self, col, row, direction, entity):
        node = self.getNodeFromTiles(col, row)
        if node is not None:
            node.allowAccess(direction, entity)

    def denyAccessList(self, col, row, direction, entities):
        for entity in entities:
            self.denyAccess(col, row, direction, entity)

    def allowAccessList(self, col, row, direction, entities):
        for entity in entities:
            self.allowAccess(col, row, direction, entity)

    def denyHomeAccess(self, entity):
        self.nodesLUT[self.homekey].denyAccess(DOWN, entity)

    def allowHomeAccess(self, entity):
        self.nodesLUT[self.homekey].allowAccess(DOWN, entity)

    def denyHomeAccessList(self, entities):
        for entity in entities:
            self.denyHomeAccess(entity)

    def allowHomeAccessList(self, entities):
        for entity in entities:
            self.allowHomeAccess(entity)

In run.py, we add these lines. For now, this restricts Pacman from moving into the ghost home, it prevents the ghosts from moving left and right when inside the home so they’ll never get stuck; when they’re in the middle of the home, their only valid direction is UP, we stop Inky from moving LEFT and Clyde from moving RIGHT so they can’t escape the home (we’ll get into why later), and we’re preventing the ghosts from entering the ghosts home; they shouldn’t be able to unless they’re in spawn mode.

def startGame(self):
        ...
        self.nodes.denyHomeAccess(self.pacman)
        self.nodes.denyHomeAccessList(self.ghosts)
        self.nodes.denyAccessList(2+11.5, 3+14, LEFT, self.ghosts)
        self.nodes.denyAccessList(2+11.5, 3+14, RIGHT, self.ghosts)
        self.ghosts.inky.startNode.denyAccess(RIGHT, self.ghosts.inky)
        self.ghosts.clyde.startNode.denyAccess(LEFT, self.ghosts.clyde)
        self.nodes.denyAccessList(12, 14, UP, self.ghosts)
        self.nodes.denyAccessList(15, 14, UP, self.ghosts)
        self.nodes.denyAccessList(12, 26, UP, self.ghosts)
        self.nodes.denyAccessList(15, 26, UP, self.ghosts)

At this point, Inky and Clyde will bounce around in the ghost home without ever leaving, and if you eat Blinky or Pinky, they’ll only circle around the home indefinitely since we restricted their access.

Add this line to the ‘checkGhostEvents’ method in run.py. Its name speaks for itself.

def checkGhostEvents(self):
   ghost.startSpawn()
   self.nodes.allowHomeAccess(ghost)
   elif ghost.mode.current is not SPAWN:

And this to the ‘normalMode’ method in ghost.py. This maintains the restriction since there’s only one circumstance when ghosts should be going in the home box.

def normalMode(self):
...
  self.homeNode.denyAccess(DOWN, self)

Now the ghost will enter the home after it’s eaten.

At this point, Inky and Clyde aren’t allowed to leave. These next lines make it so Inky can leave when Pacman eats 30 pellets and Clyde can leave when he eats 70. In run.py

def checkPelletEvents(self):
self.pellets.numEaten += 1
            if self.pellets.numEaten == 30:
                self.ghosts.inky.startNode.allowAccess(RIGHT, self.ghosts.inky)
            if self.pellets.numEaten == 70:
                self.ghosts.clyde.startNode.allowAccess(LEFT, self.ghosts.clyde)
            self.pellets.pelletList.remove(pellet)

At this point, Inky will leave the home when Pacman eats 30 pellets, and Clyde leaves when he eats 70. The overall mechanics of the game are done. Everything after this is for aesthetics; like points, life icons, and character animations

Text

As with any game, we need text to label different features.

We can fit three lines of text where each character is 16 pixels high. Below is a list of all of the texts that we need to display to the player while the game is being played.

• “SCORE“: This should be placed in the top left of the screen and have a height of 16 pixels. This is just a label string and does not change.
• “LEVEL“: This should be placed in the top right corner of the screen and have a height of 16 pixels. This is just a label string and does not change.
• score value: This is the actual numbered score which should be placed underneath the “SCORE” label. This will actively change.
• level value: This is the actual numbered level which should be placed underneath the “LEVEL” label.  
• “READY!“: This displays in the middle of the screen whenever the game begins or when the level restarts. It goes away when the player presses the space key to start the level. This text should be yellow.
• “PAUSED“: This displays in the middle of the screen when the player pauses the game by pressing the space key. It disappears when the game is unpaused. It appears in the same location as the “READY!“.
• “GAME OVER“: This displays in the middle of the screen when the player loses all lives. This text is in the same location as the previous two labels. This text should be red.
• ghost/fruit value: When Pacman eats a ghost or a fruit the value of either appears in their location. This text is white and should be 8 pixels high.

We’re creating a new file, text.py.

Every text we create has a color, size, id, and x,y position. It can also have a lifespan if we only want to display it for a certain period of time. We can also make text invisible. We’re using the PressStart2P font which is used for old-school arcade games. When you download it, make sure you add it to the folder where you’re keeping the game files, otherwise it won’t recognize the font.

This initializes all the text

import pygame
from vector import Vector2
from constants import *

class Text(object):
    def __init__(self, text, color, x, y, size, time=None, id=None, visible=True):
        self.id = id
        self.text = text
        self.color = color
        self.size = size
        self.visible = visible
        self.position = Vector2(x, y)
        self.timer = 0
        self.lifespan = time
        self.label = None
        self.destroy = False
        self.setupFont("PressStart2P-Regular.ttf")
        self.createLabel()

    def setupFont(self, fontpath):
        self.font = pygame.font.Font(fontpath, self.size)

    def createLabel(self):
        self.label = self.font.render(self.text, 1, self.color)

    def setText(self, newtext):
        self.text = str(newtext)
        self.createLabel()

    def update(self, dt):
        if self.lifespan is not None:
            self.timer += dt
            if self.timer >= self.lifespan:
                self.timer = 0
                self.lifespan = None
                self.destroy = True

    def render(self, screen):
        if self.visible:
            x, y = self.position.asTuple()
            screen.blit(self.label, (x, y))

Also add these to constants.py

SCORETXT = 0
LEVELTXT = 1
READYTXT = 2
PAUSETXT = 3
GAMEOVERTXT = 4

Add this to text.py. We just told the system that we would like to have texts in this game. So this is where we actually make the texts happen.

class TextGroup(object):
    def __init__(self):
        self.nextid = 10
        self.alltext = {}
        self.setupText()
        self.showText(READYTXT)

    def addText(self, text, color, x, y, size, time=None, id=None):
        self.nextid += 1
        self.alltext[self.nextid] = Text(text, color, x, y, size, time=time, id=id)
        return self.nextid

    def removeText(self, id):
        self.alltext.pop(id)
        
    def setupText(self):
        size = TILEHEIGHT
        self.alltext[SCORETXT] = Text("0".zfill(8), WHITE, 0, TILEHEIGHT, size)
        self.alltext[LEVELTXT] = Text(str(1).zfill(3), WHITE, 23*TILEWIDTH, TILEHEIGHT, size)
        self.alltext[READYTXT] = Text("READY!", YELLOW, 11.25*TILEWIDTH, 20*TILEHEIGHT, size, visible=False)
        self.alltext[PAUSETXT] = Text("PAUSED!", YELLOW, 10.625*TILEWIDTH, 20*TILEHEIGHT, size, visible=False)
        self.alltext[GAMEOVERTXT] = Text("GAMEOVER!", YELLOW, 10*TILEWIDTH, 20*TILEHEIGHT, size, visible=False)
        self.addText("SCORE", WHITE, 0, 0, size)
        self.addText("LEVEL", WHITE, 23*TILEWIDTH, 0, size)

    def update(self, dt):
        for tkey in list(self.alltext.keys()):
            self.alltext[tkey].update(dt)
            if self.alltext[tkey].destroy:
                self.removeText(tkey)

    def showText(self, id):
        self.hideText()
        self.alltext[id].visible = True

    def hideText(self):
        self.alltext[READYTXT].visible = False
        self.alltext[PAUSETXT].visible = False
        self.alltext[GAMEOVERTXT].visible = False

    def updateScore(self, score):
        self.updateText(SCORETXT, str(score).zfill(8))

    def updateLevel(self, level):
        self.updateText(LEVELTXT, str(level + 1).zfill(3))

    def updateText(self, id, value):
        if id in self.alltext.keys():
            self.alltext[id].setText(value)

    def render(self, screen):
        for tkey in list(self.alltext.keys()):
            self.alltext[tkey].render(screen)

Now we import it and make these additions to run.py.

from text import TextGroup

class GameController(object):
    def __init__(self):
        ...
        self.score = 0
        self.textgroup = TextGroup()

    def update(self):
        dt = self.clock.tick(30) / 1000.0
        self.textgroup.update(dt)
        ...

def updateScore(self, points):
        self.score += points
        self.textgroup.updateScore(self.score)

Still in run.py, we keep the text present when paused

def checkEvents(self):
...
if not self.pause.paused:
                            self.textgroup.hideText()
                            self.showEntities()
                        else:
                            self.textgroup.showText(PAUSETXT)

Still in run.py, we show the ghost points

def checkGhostEvents(self):
...
ghost.visible = False
                    self.updateScore(ghost.points)
                    self.textgroup.addText(str(ghost.points), WHITE, ghost.position.x, ghost.position.y, 8, time=1)
                    self.ghosts.updatePoints()
                    self.pause.setPause(pauseTime=1, func=self.showEntities)

if self.lives <= 0:
                            self.textgroup.showText(GAMEOVERTXT)
                            self.pause.setPause(pauseTime=3, func=self.restartGame)

Next we show the fruit points

def checkFruitEvents(self):
...
self.updateScore(self.fruit.points)
                self.textgroup.addText(str(self.fruit.points), WHITE, self.fruit.position.x, self.fruit.position.y, 8, time=1)

Lastly we add these to update the score as it grows

def checkPelletEvents(self):
   pellet = self.pacman.eatPellets(self.pellets.pelletList)
        if pellet:
            self.pellets.numEaten += 1
            self.updateScore(pellet.points)
            ...

def nextLevel(self):
        ...
        self.textgroup.updateLevel(self.level)

def restartGame(self):
        ...
        self.score = 0
        self.textgroup.updateScore(self.score)
        self.textgroup.updateLevel(self.level)
        self.textgroup.showText(READYTXT)

    def resetLevel(self):
        ...
        self.textgroup.showText(READYTXT)

    def render(self):
        ...
        self.textgroup.render(self.screen)
        pygame.display.update()

At this point, the game texts are shown, and update as needed.

Sprites

Now we’re gonna add the graphics/images

Technically, the computer views all images as rectangles, regardless of what shape it appears to our eyes. A circle’s position is from its center, and a rectangle’s is from its upper-left corner. As you may know, all animations are still images spliced together to give the illusion of movement. This sprite sheet contains all possible images that can be shown in the game.

We’ll make a new file called sprite.py. These tiles are 16×16, but they can be changed. The image needs to be ‘loaded’ in. We’re using pink as the transparent color since the game ignores it when drawing sprites.

import pygame
from constants import *
import numpy as np

BASETILEWIDTH = 16
BASETILEHEIGHT = 16

class Spritesheet(object):
    def __init__(self):
        self.sheet = pygame.image.load("spritesheet.png").convert()
        transcolor = self.sheet.get_at((0,0))
        self.sheet.set_colorkey(transcolor)
        width = int(self.sheet.get_width() / BASETILEWIDTH * TILEWIDTH)
        height = int(self.sheet.get_height() / BASETILEHEIGHT * TILEHEIGHT)
        self.sheet = pygame.transform.scale(self.sheet, (width, height))
        
    def getImage(self, x, y, width, height):
        x *= TILEWIDTH
        y *= TILEHEIGHT
        self.sheet.set_clip(pygame.Rect(x, y, width, height))
        return self.sheet.subsurface(self.sheet.get_clip())

Then we add Pacman’s sprites

class PacmanSprites(Spritesheet):
    def __init__(self, entity):
        Spritesheet.__init__(self)
        self.entity = entity
        self.entity.image = self.getStartImage()       

    def getStartImage(self):
        return self.getImage(8, 0)

    def getImage(self, x, y):
        return Spritesheet.getImage(self, x, y, 2*TILEWIDTH, 2*TILEHEIGHT)

Then the ghosts’

class GhostSprites(Spritesheet):
    def __init__(self, entity):
        Spritesheet.__init__(self)
        self.x = {BLINKY:0, PINKY:2, INKY:4, CLYDE:6}
        self.entity = entity
        self.entity.image = self.getStartImage()
               
    def getStartImage(self):
        return self.getImage(self.x[self.entity.name], 4)

    def getImage(self, x, y):
        return Spritesheet.getImage(self, x, y, 2*TILEWIDTH, 2*TILEHEIGHT)

And the fruits’

class FruitSprites(Spritesheet):
    def __init__(self, entity):
        Spritesheet.__init__(self)
        self.entity = entity
        self.entity.image = self.getStartImage()

    def getStartImage(self):
        return self.getImage(16, 8)

    def getImage(self, x, y):
        return Spritesheet.getImage(self, x, y, 2*TILEWIDTH, 2*TILEHEIGHT)

Make these changes in entity.py

class Entity(object):
    def __init__(self, node):
        ...
        self.image = None

    def render(self, screen):
        if self.visible:
             if self.image is not None:
                 screen.blit(self.image, self.position.asTuple())
             else:
                p = self.position.asInt()
                pygame.draw.circle(screen, self.color, p, self.radius)

Then we add the final touches to Pacman, the ghosts, and fruit, all in their own files.

First in pacman.py

from sprites import PacmanSprites

class Pacman(Entity):
    def __init__(self, node):
        ...
        self.sprites = PacmanSprites(self)

Then in ghosts.py, we import the sprites and add a line to each ghost

...
from sprites import GhostSprites

class Blinky(Ghost):
    def __init__(self, node, pacman=None, blinky=None):
        ...
        self.sprites = GhostSprites(self)


class Pinky(Ghost):
    def __init__(self, node, pacman=None, blinky=None):
        ...
        self.sprites = GhostSprites(self)


class Inky(Ghost):
    def __init__(self, node, pacman=None, blinky=None):
        ...
        self.sprites = GhostSprites(self)


class Clyde(Ghost):
    def __init__(self, node, pacman=None, blinky=None):
        ...
       self.sprites = GhostSprites(self)

And lastly we do it for fruits; in fruits.py

...
from sprites import FruitSprites

class Fruit(Entity):
    def __init__(self, node):
        ...
       self.sprites = FruitSprites(self)

At this point, the ghosts now have their OG appearances. Pacman is still a yellow circle and he’s off-center

Life Icons

We’ll start with 5 lives. Add this to sprites.py.

class LifeSprites(Spritesheet):
    def __init__(self, numlives):
        Spritesheet.__init__(self)
        self.resetLives(numlives)

    def removeImage(self):
        if len(self.images) > 0:
            self.images.pop(0)

    def resetLives(self, numlives):
        self.images = []
        for i in range(numlives):
            self.images.append(self.getImage(0,0))

    def getImage(self, x, y):
        return Spritesheet.getImage(self, x, y, 2*TILEWIDTH, 2*TILEHEIGHT)

And import into run.py adding a few more lines. As always, we’re connecting the feature to the main game controller.

from sprites import LifeSprites

class GameController(object):
    def __init__(self):
        ...
        self.lifesprites = LifeSprites(self.lives)

    def checkGhostEvents(self):
...
            self.lives -=  1
            self.lifesprites.removeImage()
...

def restartGame(self):
        ...
       self.lifesprites.resetLives(self.lives)

Then add this to the ‘render’ method still in run.py. This draws the life icons in the bottom-left corner of the screen.

 def render(self):
        ***

        for i in range(len(self.lifesprites.images)):
            x = self.lifesprites.images[i].get_width() * i
            y = SCREENHEIGHT - self.lifesprites.images[i].get_height()
            self.screen.blit(self.lifesprites.images[i], (x, y))

        pygame.display.update()

The life icons will now appear in the bottom-left part of the screen.

Graphical Mazes

Now we’re gonna replace the nodes with an actual maze. This whole time we’ve been using a sketch, now we’re doing the actual drawing. There are 10 sprites that define a maze layout. Each sprite can be rotated 90, 180, and 270 degrees. We can use one sprite for the top-left corner, then rotate the others for the other corners.

In our maze1.txt file, we’re gonna replace some of the X’s with 0-9s to define the tile sprites used.

X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
0 1 1 1 1 1 1 1 1 1 1 1 1 7 8 1 1 1 1 1 1 1 1 1 1 1 1 0
1 + . . . . + . . . . . + 3 3 + . . . . . + . . . . + 1
1 . 2 3 3 2 . 2 3 3 3 2 . 3 3 . 2 3 3 3 2 . 2 3 3 2 . 1
1 p 3 X X 3 . 3 X X X 3 . 3 3 . 3 X X X 3 . 3 X X 3 p 1
1 . 2 3 3 2 . 2 3 3 3 2 . 2 2 . 2 3 3 3 2 . 2 3 3 2 . 1
1 + . . . . + . . + . . + . . + . . + . . + . . . . + 1
1 . 2 3 3 2 . 2 2 . 2 3 3 3 3 3 3 2 . 2 2 . 2 3 3 2 . 1
1 . 2 3 3 2 . 3 3 . 2 3 3 9 9 3 3 2 . 3 3 . 2 3 3 2 . 1
1 + . . . . + 3 3 + . . + 3 3 + . . + 3 3 + . . . . + 1
0 1 1 1 1 6 . 3 9 3 3 2 | 3 3 | 2 3 3 9 3 . 6 1 1 1 1 0
X X X X X 1 . 3 9 3 3 2 | 2 2 | 2 3 3 9 3 . 1 X X X X X
X X X X X 1 . 3 3 n - - n - - n - - n 3 3 . 1 X X X X X
X X X X X 1 . 3 3 | 4 5 5 = = 5 5 4 | 3 3 . 1 X X X X X
1 1 1 1 1 6 . 2 2 | 5 X X X X X X 5 | 2 2 . 6 1 1 1 1 1
n - - - - - + - - n 5 X X X X X X 5 n - - + - - - - - n
1 1 1 1 1 6 . 2 2 | 5 X X X X X X 5 | 2 2 . 6 1 1 1 1 1
X X X X X 1 . 3 3 | 4 5 5 5 5 5 5 4 | 3 3 . 1 X X X X X
X X X X X 1 . 3 3 n - - - - - - - - n 3 3 . 1 X X X X X
X X X X X 1 . 3 3 | 2 3 3 3 3 3 3 2 | 3 3 . 1 X X X X X
0 1 1 1 1 6 . 2 2 | 2 3 3 9 9 3 3 2 | 2 2 . 6 1 1 1 1 0
1 + . . . . + . . + . . + 3 3 + . . + . . + . . . . + 1
1 . 2 3 3 2 . 2 3 3 3 2 . 3 3 . 2 3 3 3 2 . 2 3 3 2 . 1
1 . 2 3 9 3 . 2 3 3 3 2 . 2 2 . 2 3 3 3 2 . 3 9 3 2 . 1
1 P . + 3 3 + . . + . . + - - + . . + . . + 3 3 + . P 1
8 3 2 . 3 3 . 2 2 . 2 3 3 3 3 3 3 2 . 2 2 . 3 3 . 2 3 7
7 3 2 . 2 2 . 3 3 . 2 3 3 9 9 3 3 2 . 3 3 . 2 2 . 2 3 8
1 + . + . . + 3 3 + . . + 3 3 + . . + 3 3 + . . + . + 1
1 . 2 3 3 3 3 9 9 3 3 2 . 3 3 . 2 3 3 9 9 3 3 3 3 2 . 1
1 . 2 3 3 3 3 3 3 3 3 2 . 2 2 . 2 3 3 3 3 3 3 3 3 2 . 1
1 + . . . . . . . . . . + . . + . . . . . . . . . . + 1
0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0
X X X X X X X X X X X X X X X X X X X X X X X X X X X X
X X X X X X X X X X X X X X X X X X X X X X X X X X X X

And add this to sprites.py

class MazeSprites(Spritesheet):
    def __init__(self, mazefile):
        Spritesheet.__init__(self)
        self.data = self.readMazeFile(mazefile)

    def getImage(self, x, y):
        return Spritesheet.getImage(self, x, y, TILEWIDTH, TILEHEIGHT)

    def readMazeFile(self, mazefile):
        return np.loadtxt(mazefile, dtype='<U1')

    def constructBackground(self, background, y):
        for row in list(range(self.data.shape[0])):
            for col in list(range(self.data.shape[1])):
                if self.data[row][col].isdigit():
                    x = int(self.data[row][col]) + 12
                    sprite = self.getImage(x, y)
                    background.blit(sprite, (col*TILEWIDTH, row*TILEHEIGHT))
                elif self.data[row][col] == '=':
                    sprite = self.getImage(10, 8)
                    background.blit(sprite, (col*TILEWIDTH, row*TILEHEIGHT))

        return background

Then modify the run.py with these 2 lines. We put them under the ‘setBackground’ line since the maze is technically the background

from sprites import MazeSprites  

def startGame(self):
        self.setBackground()
        self.mazesprites = MazeSprites("maze1.txt")
        self.background = self.mazesprites.constructBackground(self.background, self.level%5)

At this point, the sprites are, present, but still kinda off. The sketch is still there too.

Graphical Mazes Pt 2

Create a maze_rotation.py file. It’ll look like the other maze file except this only has digits 0-3. Each digit represents the rotation of a sprite. 0 is none, 1 is 90 degrees, 2 is 180, and 3 is 270.

. . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3
1 . . . . . . . . . . . . 1 3 . . . . . . . . . . . . 3
1 . 0 0 0 3 . 0 0 0 0 3 . 1 3 . 0 0 0 0 3 . 0 0 0 3 . 3
1 . 1 . . 3 . 1 . . . 3 . 1 3 . 1 . . . 3 . 1 . . 3 . 3
1 . 1 2 2 2 . 1 2 2 2 2 . 1 2 . 1 2 2 2 2 . 1 2 2 2 . 3
1 . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1 . 0 0 0 3 . 0 3 . 0 0 0 0 0 0 0 3 . 0 3 . 0 0 0 3 . 3
1 . 1 2 2 2 . 1 3 . 1 2 2 3 0 2 2 2 . 1 3 . 1 2 2 2 . 3
1 . . . . . . 1 3 . . . . 1 3 . . . . 1 3 . . . . . . 3
1 2 2 2 2 3 . 1 1 0 0 3 . 1 3 . 0 0 0 2 3 . 0 2 2 2 2 2
. . . . . 1 . 1 0 2 2 2 . 1 2 . 1 2 2 3 3 . 3 . . . . .
. . . . . 1 . 1 3 . . . . . . . . . . 1 3 . 3 . . . . .
. . . . . 1 . 1 3 . 0 0 0 . . 0 0 3 . 1 3 . 3 . . . . .
0 0 0 0 0 2 . 1 2 . 1 . . . . . . 3 . 1 2 . 1 0 0 0 0 0
. . . . . . . . . . 1 . . . . . . 3 . . . . . . . . . .
2 2 2 2 2 3 . 0 3 . 1 . . . . . . 3 . 0 3 . 0 2 2 2 2 2
. . . . . 1 . 1 3 . 1 2 2 2 2 2 2 2 . 1 3 . 3 . . . . .
. . . . . 1 . 1 3 . . . . . . . . . . 1 3 . 3 . . . . .
. . . . . 1 . 1 3 . 0 0 0 0 0 0 0 3 . 1 3 . 3 . . . . .
0 0 0 0 0 2 . 1 2 . 1 2 2 3 0 2 2 2 . 1 2 . 1 0 0 0 0 3
1 . . . . . . . . . . . . 1 3 . . . . . . . . . . . . 3
1 . 0 0 0 3 . 0 0 0 0 3 . 1 3 . 0 0 0 0 3 . 0 0 0 3 . 3
1 . 1 2 3 3 . 1 2 2 2 2 . 1 2 . 1 2 2 2 2 . 1 0 2 2 . 3
1 . . . 1 3 . . . . . . . . . . . . . . . . 1 3 . . . 3
1 0 3 . 1 3 . 0 3 . 0 0 0 0 0 0 0 3 . 0 3 . 1 3 . 0 0 3
1 2 2 . 1 2 . 1 3 . 1 2 2 3 0 2 2 2 . 1 3 . 1 2 . 1 2 3
1 . . . . . . 1 3 . . . . 1 3 . . . . 1 3 . . . . . . 3
1 . 0 0 0 0 0 2 1 0 0 3 . 1 3 . 0 0 0 2 1 0 0 0 0 3 . 3
1 . 1 2 2 2 2 2 2 2 2 2 . 1 2 . 1 2 2 2 2 2 2 2 2 2 . 3
1 . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . .

Add these lines to sprites.py

class MazeSprites(Spritesheet):
    def __init__(self, mazefile, rotfile):
Spritesheet.__init__(self)
        self.data = self.readMazeFile(mazefile)
        self.rotdata = self.readMazeFile(rotfile)

    def constructBackground(self, background, y):
...
sprite = self.getImage(x, y)
                    rotval = int(self.rotdata[row][col])
                    sprite = self.rotate(sprite, rotval)
...

return background

def rotate(self, sprite, value):
       return pygame.transform.rotate(sprite, value*90)

Then add the file into run.py

def startGame(self):
        self.setBackground()
        self.mazesprites = MazeSprites("maze1.txt", "maze1_rotation.txt")

We can remove the ‘self.nodes.render’ line in the ‘render’ method

In pellets.py, replace the ‘self.radius’ and ‘collideRadius’ lines in the ‘init’ method with the 2 lines shown, and the ‘p’ in the ‘render’ method below that.

class Pellet(object):
    def __init__(self, row, column):
...
        self.color = WHITE
self.radius = int(2 * TILEWDITH / 16)
        self.collideRadius = int(2 * TILEWIDTH / 16)

    def render(self, screen):
        if self.visible:
adjust = Vector2(TILEWIDTH, TILEHEIGHT) / 2
            p = self.position + adjust
            pygame.draw.circle(screen, self.color, p.asInt(), self.radius)

and this in entity.py, replacing ‘screen.blit’

def render(self, screen):
        if self.visible:
            if self.image is not None:
                adjust = Vector2(TILEWIDTH, TILEHEIGHT) / 2
                p = self.position - adjust
                screen.blit(self.image, p.asTuple())
    else:

The sketch lines are now gone, leaving us with a pristine maze graphic. Our only flaw is the characters look kinda off-center. The last 2 additions we made were supposed to fix that, but it’s still off. This is another issue I’m gonna let stay.

Animate Pacman

Now we’re gonna turn Pacman from a basic yellow circle to his famous appearance; which is still the circle, just with an opening.

Create an animation.py file

from constants import *

class Animator(object):
    def __init__(self, frames=[], speed=20, loop=True):
        self.frames = frames
        self.current_frame = 0
        self.speed = speed
        self.loop = loop
        self.dt = 0
        self.finished = False

    def reset(self):
        self.current_frame = 0
        self.finished = False

    def update(self, dt):
        if not self.finished:
            self.nextFrame(dt)
        if self.current_frame == len(self.frames):
            if self.loop:
                self.current_frame = 0
            else:
                self.finished = True
                self.current_frame -= 1
   
        return self.frames[self.current_frame]

    def nextFrame(self, dt):
        self.dt += dt
        if self.dt >= (1.0 / self.speed):
            self.current_frame += 1
            self.dt = 0

Add these to sprite.py

from animation import Animator

class PacmanSprites(Spritesheet):
    def __init__(self, entity):
        ...
        self.animations = {}
        self.defineAnimations()
        self.stopimage = (8, 0)


def defineAnimations(self):
        self.animations[LEFT] = Animator(((8,0), (0, 0), (0, 2), (0, 0)))
        self.animations[RIGHT] = Animator(((10,0), (2, 0), (2, 2), (2, 0)))
        self.animations[UP] = Animator(((10,2), (6, 0), (6, 2), (6, 0)))
        self.animations[DOWN] = Animator(((8,2), (4, 0), (4, 2), (4, 0)))

    def update(self, dt):
        if self.entity.direction == LEFT:
            self.entity.image = self.getImage(*self.animations[LEFT].update(dt))
            self.stopimage = (8, 0)
        elif self.entity.direction == RIGHT:
            self.entity.image = self.getImage(*self.animations[RIGHT].update(dt))
            self.stopimage = (10, 0)
        elif self.entity.direction == DOWN:
            self.entity.image = self.getImage(*self.animations[DOWN].update(dt))
            self.stopimage = (8, 2)
        elif self.entity.direction == UP:
            self.entity.image = self.getImage(*self.animations[UP].update(dt))
            self.stopimage = (10, 2)
        elif self.entity.direction == STOP:
            self.entity.image = self.getImage(*self.stopimage)

    def reset(self):
        for key in list(self.animations.keys()):
            self.animations[key].reset()

And update his sprites in pacman.py

def update(self, dt):	
        self.sprites.update(dt)
        self.position += self.directions[self.direction]*self.speed*dt
        ...

Pacman now moves his mouth.

Animate Ghosts

define them in sprites.py

def update(self, dt):
        x = self.x[self.entity.name]
        if self.entity.direction == LEFT:
            self.entity.image = self.getImage(x, 8)
        elif self.entity.direction == RIGHT:
            self.entity.image = self.getImage(x, 10)
        elif self.entity.direction == DOWN:
            self.entity.image = self.getImage(x, 6)
        elif self.entity.direction == UP:
            self.entity.image = self.getImage(x, 4)

and add this line to the update method in ghosts.py

def update(self, dt):
        self.sprites.update(dt)
        self.mode.update(dt)
...

Add this to sprites.py

def update(self, dt):
        x = self.x[self.entity.name]
        if self.entity.mode.current in [SCATTER, CHASE]:
...
elif self.entity.direction == UP:
                self.entity.image = self.getImage(x, 4)
        elif self.entity.mode.current == FREIGHT:
            self.entity.image = self.getImage(10, 4)
        elif self.entity.mode.current == SPAWN:
            if self.entity.direction == LEFT:
                self.entity.image = self.getImage(8, 8)
            elif self.entity.direction == RIGHT:
                self.entity.image = self.getImage(8, 10)
            elif self.entity.direction == DOWN:
                self.entity.image = self.getImage(8, 6)
            elif self.entity.direction == UP:
               self.entity.image = self.getImage(8, 4)

The ghosts’ eyes now move in the direction they’re going in.

Pacman Death

Now onto the iconic death animation. I have to say again that this is the main game-breaking flaw that I couldn’t figure out in time. The animation happens, but the game crashes when he dies. So you technically only get one life to play this.

One main difference with this animation compared to the others is that it doesn’t loop. We only need it to occur once and allow the game to move on. To do this, we add these to sprites.py. This a

...
DEATH = 5

    def defineAnimations(self):
...
self.animations[DOWN] = Animator(((8,2), (4, 0), (4, 2), (4, 0)))
        self.animations[DEATH] = Animator(((0, 12), (2, 12), (4, 12), (6, 12), (8, 12), (10, 12), (12, 12), (14, 12), (16, 12), (18, 12), (20, 12)), speed=6, loop=False)

def update(self, dt):
        if self.entity.alive == True:
...
elif self.entity.direction == STOP:
                self.entity.image = self.getImage(*self.stopimage)
        else:
           self.entity.image = self.getImage(*self.animations[DEATH].update(dt))

this in pacman.py

    def reset(self):
...
self.alive = True
        self.image = self.sprites.getStartImage()
        self.sprites.reset()

run.py, take out ‘self.pacman.update’

    def update(self):
...
self.checkFruitEvents()

        if self.pacman.alive:
            if not self.pause.paused:
                self.pacman.update(dt)
        else:
            self.pacman.update(dt)
        afterPauseMethod = self.pause.update(dt)

Pacman now has a death animation. Still can’t reset after he dies though.

Level Flash

in run.py

 class GameController(object):
    def __init__(self):
...
self.background = None
        self.background_norm = None
        self.background_flash = None
        self.clock = pygame.time.Clock()
...
self.lifesprites = LifeSprites(self.lives)
        self.flashBG = False
        self.flashTime = 0.2
        self.flashTimer = 0

take out the first 2 self.background

    def setBackground(self):
self.background_norm = pygame.surface.Surface(SCREENSIZE).convert()
        self.background_norm.fill(BLACK)
        self.background_flash = pygame.surface.Surface(SCREENSIZE).convert()
        self.background_flash.fill(BLACK)
        self.background_norm = self.mazesprites.constructBackground(self.background_norm, self.level%5)
        self.background_flash = self.mazesprites.constructBackground(self.background_flash, 5)
        self.flashBG = False
        self.background = self.background_norm

still run.py

 def update(self):
        ...
else:
            self.pacman.update(dt)

        if self.flashBG:
            self.flashTimer += dt
            if self.flashTimer >= self.flashTime:
                self.flashTimer = 0
                if self.background == self.background_norm:
                    self.background = self.background_flash
                else:
                    self.background = self.background_norm
        afterPauseMethod = self.pause.update(dt)

def checkPelletEvents(self):
        ...
            if self.pellets.isEmpty():
                self.flashBG = True

@grchab

Part 1/2 of Algorithms 2: Basic Data Structures; Full post on blog #algorithm #datastructures #array #linkedlist #learnontiktok #tech #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

@grchab

Part 2/2 of Algorithms 2: Basic Data Structures; Full post on blog #algorithm #datastructures #learnontiktok #tech #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

Before I jump into algorithms, I need to understand data structures. Here’s a list of them:

• Arrays
• Linked lists
• Trees
• Stacks & Queues
• Heaps
• Hash tables
• Graphs
• Disjoint set

I know there are some more, these are just the ones I need to understand starting off.

To start, I’ll be going over the basics of each structure just to get acquainted with them.

First, we have to understand the 2 main types of data structures, linear and nonlinear. Those kinda speak for themselves, but I’ll explain more as we unpack each structure. There are 2 subtypes of linear structures, static and dynamic, which mainly pertain to their memory sizes. One is fixed and one is flexible m

Array

Arrays are a linear set of elements. Each element’s place is called an index. You can look at it like a flight of stairs that holds whatever item you set on each step. If you want to retrieve that item, you call it by the step it’s on, which is the index. Or you can look at it like those pill sorters with the days of the week on them. If you’re not sure which pill you take on a certain day, you simply open the lid of that day (the index), and look at what pills are in there (the elements).

This is the simplest form of information container. It’s static, so the number of elements is determined at the time of creation. You can change the values of an element, but you can’t add or remove any. There are also dynamic arrays too, which do allow for this. So they obviously sound better. Just like lists vs tuples in Python or floating points vs integers in SQL, even though one is clearly more flexible, it takes more memory (space). So it’s ok to stick with the fixed version if we know the number of elements is permanent.

Lastly, arrays come in different dimensions. 1D is a horizontal line of blocks, a single row.

2D is a grid or matrix with rows and columns.

And 3D is a set of multiple 2Ds.

Linked List

There are 4 types of linked lists: singly, doubly, circular, and circular doubly.

Singly

A singly linked list is made of a line of 2-section boxes called nodes. The first node is called the head, and the last is the tail. The first section of the node is the data element and the second section is the pointer where it says ‘next’.

Now since it’s a linked list, it doesn’t allow for random access. In arrays, we can access any element by calling its index and ignoring the other ones, which is random access. In linked lists, if we want to call an element, we have to start from the head node and work our way down to the one we’re looking for. This is called traversing. And singlys are unidirectional, meaning they can only traverse from the head to the tail, from left to right.

Doubly

A doubly has an extra section for a previous pointer. This allows bidirectional traversing, it can start from a middle node and move forward or backward. So this is a form of random access, but not as explicit as an array’s. We’ll get into the technicalities later.

Circular

A circular linked list is an extension of a singly. Once it reaches the tail node, it circles back to the head. This is used for a singly that requires a loop, especially for real-time applications. Since it loops, there is no null. A main concern with circulars is they need to be manually stopped, or else they’ll loop indefinitely.

Doubly Circular

Doubly circulars are self-explanatory since I’ve gone through the others. In terms of their application, I’m not yet sure what they’d be used for.

Stacks & Queues

A stack is a linear structure that vertically contains data. Like a stack of books, it follows a last-in-first-out principle (LIFO). Whichever is on top, is the one to get replaced. Adding an element to the stack is called a push and removing it is a pop.

A queue is similar, except it’s horizontal and it follows a first-in-first-out (FIFO) principle. Visually, it looks the same as an array, but they’re used in different ways. Stacks and queues don’t have indices like arrays, you can’t directly access an element in the middle. A queue’s first (leftmost) element is considered the front, and the last (rightmost) is the rear. With a row of books, if you enqueue (add) a book to the rear, you must dequeue (remove) a book from the front.

Disjoint Set

Disjoint means 2 or more sets have no elements in common. No overlap.

All I can say about it now is it’s used to manipulate sets of elements without mixing them up. It uses a variety of union techniques to pick out the overlaps and evaluate what to do with them. It’s a lot more than that but we’ll have to expound on it in a separate post.

Hash Tables

Hash tables are an advanced form of arrays. I’ve been trying hard to simplify the differences. All I can say for now is they allow random access, which means faster lookup, and they take up more memory. The other difference will require me to explain some of the properties I listed. So we’ll to get to this later.

Trees

Trees are a nonlinear structure that follow a parent-child hierarchy.

The most basic tree is a binary tree. It’s binary because each node only has 2 children at most.

The first node is called the root, which is the parent. 2 and 3 are its children, thus they’re siblings. These may also be called the ‘left’ and ‘right’ child.

There’s a ternary tree where each node has 3 children.

And there’s an n-ary tree which means each node can have a varied number of children.

Any node that doesn’t have a child is called a leaf.

There are variations of trees too but we’ll get to those in a separate post

Heaps

A heap is more of an advanced method of dealing with trees. It’s not a separate data structure. It deals with a heap property which is prioritizing certain elements. Mainly the parent nodes that are less or greater than their children. Its main purpose is efficient extraction. We’ll elaborate on its other functions later.

Graphs

There are a handful of types of graphs so we’ll start with the main types: directed and undirected, weighted and unweighted.

All graphs are made of nodes and edges (or vertices and links). The nodes are the actual data elements and the edges are the relationship between elements. Directed edges have a one-way relationship. A may follow B, but it doesn’t mean B follows A. Undirected means the relationship is mutual, where A follows B and B follows A. Weighted edges add a value to the relationship, like the number of times 2 accounts have interacted or how much money they’ve sent to each other. Unweighted implies that all nodes are equal.

Now that I got the basic structures down, I’m going to jump into algorithm analysis.

@grchab

Part 1/6 of Python 14: Pong Game Analysis – Intro; full post & code on blog #python #pythonprogramming #learnpython #learnpythonprogramming #learntocode #pong #ponggame #gamedev

♬ original sound – Curiosity Corner 🙇🏽‍♂️

Past learning the basics of Python l wasn’t sure what to apply it to. The best way to learn is by doing, but I don’t feel like making a weather app or a calculator. Anything I do want to make is above my skill level. So as a next step, I’m gonna dabble in game development. I’m starting with the most basic arcade game there is, Pong. Geeksforgeeks.com has the entire code that actually functions on its run. I pasted it to the bottom of this post. I’ll be analyzing each line to understand its purpose

The first thing I learned with this is using libraries with Python. A library is a toolbox that can be used for a variety of operations. Each library has its own set of methods for its niche. A few examples are NumPy which is used for advanced math like calculus or statistics, or Matplotlib which is used for data visualizations, like charts and graphs. For this, I’ll be using the Pygame library whose name speaks for itself.

If you want to do this yourself, you gotta do 3 things, and this can only be done on a computer.

1. Download the Python language from python.org
2. Download Pygame from pygame.org
3. Open the IDLE (Integrated Development and Learning Environment) that comes with the Python language. This is the word doc of programming. There are other ones with more capabilities, but this is the most basic one that’ll get the job done.

Once you got those done, if you paste the full code and run it, the game should be functional.

Remember any sentence with a hash (#) in front of it is a comment. These are used to label the blocks of code. They’re not code themselves.

Also notice that every function, except for the ‘init’ at the beginning and the ‘main’ one at the end, has ‘self’ as its first argument. Keep that in mind.

First things first, we have to import the Pygame library.

import pygame

We use an initialize function to launch it.

pygame.init()

Next, we set the text font for the player names that’ll show up top. 20 is the font size. ‘freesandbold’ is a font style by Pygame. It’s not technically imported, but it’s not a regular system font. That’s why we put the capital F ‘Font’ class right after ‘pygame.font’. If we wanted to use a system font like Arial, we would use the ‘SysFont’ class.

font20 = pygame.font.Font('freesansbold.ttf', 20)

Next block speaks for itself. We’re setting the colors that’ll be in the game. Using RGB values.

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 00)

Next we set the display dimensions, width and height. Then we set a ‘screen’ variable to display the window surface. I tried setting this to fill my computer’s resolution, but it was so big you couldn’t see the paddles. Even cutting the dimensions in half was still too much. With this 900×600, it shows as a fixed window that you can’t maximize. ‘pygame.display.set_mode’ is a built-in function that’s vital for creating this display. The ‘set_caption’ line under it is where we name the program that’ll show as the window name.

WIDTH, HEIGHT = 900, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pong")

Lastly for the general setup, even though the end of the function says ‘Clock’, this actually sets up the frame rate of the game. ‘FPS’ is a custom variable, just how the first ‘clock’ is. This means those names do nothing for the actual function, you could call them ‘googoo & gaga’ if you wanted to. We just use them to be descriptive and use common sense. After you call the ‘Clock’ function, it knows that any variable you set to a number after that will be the frame rate. This is another one of those built-in functions of Pygame.

clock = pygame.time.Clock()
FPS = 30

Paddles

@grchab

Part 2/6 of Python 14: Pong Game Analysis – Paddles 1; full post & code on blog #python #pythonprogramming #learnpython #learnpythonprogramming #learntocode #pong #ponggame #gamedev

♬ original sound – Curiosity Corner 🙇🏽‍♂️

@grchab

Part 3/6 of Python 14: Pong Game Analysis – Paddles 2; full code & post on blog #python #pythonprogramming #learnpython #learnpythonprogramming #learntocode #pong #ponggame #gamedev

♬ original sound – Curiosity Corner 🙇🏽‍♂️

The ‘Striker’ class represents the paddles in the game. All of these blocks with ‘def’ are a series of functions we’re using to control the paddles’ behavior. The first one is a constructor that initializes the paddles’ position.

class Striker:
		# Take the initial position, dimensions, speed and color of the object
	def __init__(self, posx, posy, width, height, speed, color):
		self.posx = posx
		self.posy = posy
		self.width = width
		self.height = height
		self.speed = speed
		self.color = color

The use of ‘self’ looks redundant, but here’s why it’s not. It’s conventionally set as the first argument, even though it’s not technically one. We see the arguments after ‘self’ are the attributes of the paddles. The paddles, ‘geek1 & geek2’, are defined in the ‘main’ class further down. And when they’re defined, we see the arguments in those are set to the attributes. So why can’t we just use the initialization function with those attribute arguments and define the strikers right under it like this?

def __init__(posx, posy, width, height, speed, color):
    geek1 = Striker(20, 0, 10, 100, 10, GREEN)
    geek2 = Striker(WIDTH-30, 0, 10, 100, 10, GREEN)

This wouldn’t run. Without ‘self’, the attributes would be stuck within the class as local variables, making them unable to branch out to other instances, which are the paddles in this case. Put simply, for the attributes to actually be applied, they need a ‘self’ reference so the system knows to apply it to the instance we’re working with. It’s another one of those anal computer tidbits.

‘Posx & y’ are the positions of the paddles using basic coordinates. ‘Width ‘and ‘height’ are the dimensions of the paddle. ‘Speed’ is how fast the paddles move when the control key is pressed. And color speaks for itself. Again, these are the arguments for the ‘initialize’ function.

After listing the regular arguments. The ‘.geekRect’ after ‘self’ is just a variable name. ‘pygame.Rect’ is a class that deals with rectangles in the game. The arguments in that function with the positions and dimensions are directed to the rectangle.

self.geekRect = pygame.Rect(posx, posy, width, height)

Below that is ‘pygame.draw.rect’. This apparently draws the rectangle, but they still show even if I delete this line. We’ll see why it matters in the next line. And again, this was all under the initialize function. Now that it’s laid out, we start making them work.

self.geek = pygame.draw.rect(screen, self.color, self.geekRect)

The next standalone method displays the rectangle using the same ‘draw’ line we just went over. Without this line, nothing shows up, but it still works if I delete the first ‘draw.rect’ line. So we may be able to call that one redundant since the game runs the same with or without it.

def display(self):
	self.geek = pygame.draw.rect(screen, self.color, self.geekRect)

The ‘update’ method contains a ‘yFac’ argument which is for its factor on the y-axis. As we know the paddles can only move up & down, but we also can’t let them slide out of the display. This function is the start of setting those boundaries so they can only go to the top or bottom of the screen.

def update(self, yFac):
	self.posy = self.posy + self.speed*yFac

Unlike the coordinate grids we use in math, negative y-numbers are higher, and positive are lower. Coordinate (0,0) is the top-left corner of the screen. So to stop the paddle from going above the screen, we set a conditional so if y’s position is less than or equal to 0, it’ll restrict the paddle to y-0 and nothing lower.

if self.posy <= 0:
	self.posy = 0

To keep it from passing the bottom, we have to consider the paddle’s height. When passing above the screen, the head of the rectangle is its leading point. When passing the bottom, it goes foot-first. Again, since y-values go up as the space goes lower, the rectangle’s height was generated from the top-down. So the very bottom of the paddle is where it’s 100 pixels. We didn’t do this for this top boundary since the paddle’s head has nothing to it. Its length works down.

elif self.posy + self.height >= HEIGHT:
	self.posy = HEIGHT-self.height

The height of the screen (600) minus the rectangle’s height (100). So ‘posy: 500’ represents the zone the paddle is not allowed to move past.

I’m not sure what this next ‘self.geekRect’ function does. The comment says it updates the geekRect with new values, but if I delete it, the paddles won’t move despite pressing the keys. This is the one line I’m uncertain about. I don’t know why we’re referencing the rectangle again, but I know the game doesn’t function without it, so it is necessary. I want to see how this works for other games down the line.

self.geekRect = (self.posx, self.posy, self.width, self.height)

The next function is described in its name, it displays the score. It starts with a ‘text’ variable set to a ‘font.render’ method. The first argument in this method concatenates ‘text’ which will be the player’s name, and ‘score’ is set as a string. Even though score is a number, it has to stay a string for rendering purposes. And remember, a string can contain numbers too. The ‘True’ pertains to aliasing, which is a feature where the text is deblured to look sharper. If it was set to ‘False’ it would disable the feature.

def displayScore(self, text, score, x, y, color):
	text = font20.render(text+str(score), True, color)
	textRect = text.get_rect()
	textRect.center = (x, y)

The fact the system inherently knows ‘True/False’ to pertain to that is a convention. Just as you see here, it’s typical for the antialiasing argument to be second in the ‘font.render’ method.

And of course, the color is set as an argument to initialize it.

The ‘textRect’ variable creates a function that creates the rectangle that surrounds the text. Like a text box.

And the last line with the ‘.center’ attribute is what centers the text within that rectangle. The ‘x & y’ just specify it should be a position on the box. Seems redundant, but the game doesn’t run if it’s not there.

For the ‘screen.blit’ line, blit means to place one surface onto another, which is the text onto the screen in this case. ‘text’ is the text itself, and ‘textRect’ is the text box we created. So we’re technically placing 2 things onto the screen. One concern I had for this was why is the text being put under the Striker class and not the main class? The main reason is that the paddles have their own scores they have to manage. So it makes more sense to keep that method with this class for organization.

screen.blit(text, textRect)

And lastly the ‘return’ statement allows ‘geekRect’ to be called, but not modified from the outside. A pattern I’ve noticed is you have to establish a thing, give it the right to be modified, then give it the right to be called.

def getRect(self):
	return self.geekRect

Ball

@grchab

Part 4/6 of Python 14: Pong Game Analysis – Ball 1; full code & post on blog #python #pythonprogramming #learnpython #learnpythonprogramming #learntocode #pong #ponggame #gamedev

♬ original sound – Curiosity Corner 🙇🏽‍♂️

@grchab

Part 5/6 of Python 14: Pong Game Analysis – Ball 2; full code & post on blog #python #pythonprogramming #learnpython #learnpythonprogramming #learntocode #pong #ponggame #gamedev

♬ original sound – Curiosity Corner 🙇🏽‍♂️

Now onto the ball. Just how we did with the striker class, we set all the ‘self’ statements to initialize the characteristics of the ball. The one new one is the radius of the ball since it’s a circle. The x and y-factors are here for the initial motion of the ball. Since the first player starts on the left, the ball will travel right (hence xFac 1) and up (hence yFac -1). Again, this is for the first serve of the game. After that, we use the ‘draw’ feature to create the ball. Since the ball moves on its own, the ‘firstTime’ attribute set to 1 tells the system it hasn’t crossed a boundary yet. Once it crosses one of those bounds, ‘firstTime’ is set to 0, to which it then resets to 1 putting the ball back in the center. If we set it to 0 by default, the ball would fly past the boundary indefinitely and never respawn or count for a point. The ‘firstTime’ attribute isn’t the literal first time. It just manages the ball so it behaves the same way on every serve. The game is technically over once it crosses a bound, so we have to keep it on a loop.

class Ball:
	def __init__(self, posx, posy, radius, speed, color):
		self.posx = posx
		self.posy = posy
		self.radius = radius
		self.speed = speed
		self.color = color
		self.xFac = 1
		self.yFac = -1
		self.ball = pygame.draw.circle(
			screen, self.color, (self.posx, self.posy), self.radius)
		self.firstTime = 1

The next is a ‘display’ function like we did for the paddles. We call all the superficial properties of the ball as arguments. Also notice that posx and y are grouped as a tuple. This is a syntax standard for coordinates since it makes no sense to only display one.

def display(self):
	self.ball = pygame.draw.circle(
		screen, self.color, (self.posx, self.posy), self.radius)

The ‘update’ function modifies the ball’s position based on its speed and direction factors. The ‘self.posx’ and ‘self.posy’ variables are adjusted by adding the product of the speed and the respective axis factor. For instance, suppose the initial y-position is 100, and the ball maintains a constant speed of 5, with an initial y-factor of -1 (indicating an upward direction). When the ball hits the top boundary and changes direction (due to the y-factor of -1), the new y-position is calculated as follows: 100 + (5 * (-1)), resulting in a new y-position of 95. The same process applies to the x-position.

def update(self):
	self.posx += self.speed*self.xFac
	self.posy += self.speed*self.yFac

If we made the y-factor 1, the ball would travel well past the top boundary and respawn in a perpetual upward direction.

Now we set the boundaries of the game area so the ball knows to bounce off the walls. This is where conditionals come in. The first ‘self.posy’ is set to less than or equal to 0. Remember y0 is the top of the screen. As to why we have to include equal to 0, I’m uncertain. Supposedly, leaving it out will make the ball partially clip out of bounds, but it does that even with the equal sign. Regardless, by setting the less-than sign, the ball knows it has no business anywhere under y0.

if self.posy <= 0 or self.posy >= HEIGHT:
	self.yFac *= -1

The second ‘self.posy’ is for the bottom of the screen. We set the ball’s y-position to be greater than or equal to the height of the display.

If it was just greater than (>) it would be the same.

If it was just equal (==) to the height, the ball will start off moving up, then once it passes the bottom, it waits to pass the player’s goal before respawning in a downward direction. It never reaches the paddles after that.

If it was less than (<), with or without the equal, the ball travels horizontally in a squiggle. Why is this? The correct version is greater than because when the ball passes the bottom, its y-position is greater than 600, to which it knows to respawn at that point. When we set it to less than the height (600), we’re telling the ball from its initial spawn point that it’s at the bottom. The whole display is less than 600. This restricts the ball’s y-position since we took away any room it had to move on that axis.

At last, the ‘self.yFac’ statement ensures the y-position is always multiplied by -1. This means when the ball hits the top, since that’s going towards the negative, the -1 will revert that to positive 1, which makes the ball travel downward. And when the ball hits the bottom, who’s positive, it keeps the -1 which makes the ball travel upward. Simply put, this is what makes the ball change its vertical direction when it hits the floor or ceiling.

Next we do this with the x-coordinates, the ball’s horizontal movement. The key difference here is the ball doesn’t bounce off the sides. The entire space behind a paddle is a goal. So we start the ‘self.posx’ the same as we did with y. First set it to less than or equal to 0. x0 is the very left of the screen, any more left is negative. So when the ball crosses into that x-negative, the ‘self.firstTime’ flag is what’ll count that movement as a point. The ‘return 1’ adds a point to the right paddle, since the ball went out the left bounds.

if self.posx <= 0 and self.firstTime:
	self.firstTime = 0
		return 1

This elif (else-if, used when the first ‘if’ doesn’t work) manages the left paddle’s score. The ‘self.posx’ is set to be greater than or equal to the width of the game window. Since x-positive is to the right, and the game window’s width is 900, when the ball’s x-position is at and trying to pass 900, the system knows to give the left paddle a point.

elif self.posx >= WIDTH and self.firstTime:
	self.firstTime = 0
		return -1

‘self.firstTime’ keeps these scores as a singular instance. Otherwise the score would rapidly climb after only one goal. The ‘return -1’ has to be negative. If it were positive, the right paddle would get a point even if it was scored on.

And the ‘else return 0’ is the default ‘no score’ if no goal has been made.

else:
	return 0

The ‘reset’ function manages what happens to the ball after a score. ‘self.posx & y’ makes the ball restart at half the screen’s width and half its height, which is the direct center of the display. The ‘-1 xFac’ makes the ball shift the opposite direction of whatever it just scored. If it went out to the left, it restarts being served to the right. We then set the ‘firstTime’ to 1 so it knows to execute this function the next time the ball goes out.

def reset(self):
	self.posx = WIDTH//2
	self.posy = HEIGHT//2
	self.xFac *= -1
	self.firstTime = 1

This next ‘hit’ method makes the ball reflect off anything it hits horizontally, which will be strictly the paddles. The ‘xFac’ is -1 so that if the ball collides with the left paddle, which is a negative-x, it reverts to positive 1 so it bounces to the right. If hits the right paddle, which is positive-x, it’s again inverted by -1, so it bounces to the negative direction left.

def hit(self):
	self.xFac *= -1

The last code of this class is for creating a rectangle around the ball that’ll be used for collision detection.

def getRect(self):
	return self.ball

Game Manager

@grchab

Part 6/6 of Python 14: Pong Game Analysis – Game Manager; full code & post on blog #python #pythonprogramming #learnpython #learnpythonprogramming #learntocode #pong #ponggame #gamedev

♬ original sound – Curiosity Corner 🙇🏽‍♂️

Now that the objects are created, we can finally set the game’s logic.

The ‘True’ assigned ‘running’ variable under the ‘main’ function is what makes the game run indefinitely. If it was set to ‘False’, the game wouldn’t start at all.

def main():
	running = True

These next 2 ‘geek’ lines are where we illustrate the paddles. The set of 5 numbers represents posx, posy, width, height, speed, and of course the color is written at the end. So the ‘geek1’ paddle (the left one) is 20 pixels from the left of the screen, it starts at y0 which is the very top of the screen, it has a width of 10, a height of 100, a speed of 10, and it’s green.

geek1 = Striker(20, 0, 10, 100, 10, GREEN)

The right paddle ‘geek2’s ‘posx’ is set to be 30 pixels away from the width of the screen. Again, the far left is x0, so the far right is x900, since we set the screen’s width to be 900. So since it’s 30 pixels away from 900, we could technically just set geek2’s posx to be 870, but either way works.

Also you might notice that geek2 is 10 extra pixels away from the right edge as geek1 is from the left. This is just one of those visual balance things where an anomaly looks better than numerical equals. The first pic is with the extra 10. The second is without it.

geek2 = Striker(WIDTH-30, 0, 10, 100, 10, GREEN)

Next we do the same with defining the ‘ball’ variable. The width and height divided by 2 tell the ball to start at the direct center of the screen. The first 7 is the ball’s radius and the second 7 is its speed. Then we close it out making the ball white.

ball = Ball(WIDTH//2, HEIGHT//2, 7, 7, WHITE)

The ‘listofGeeks’ variable after that is meant to store the references for the paddles.

listOfGeeks = [geek1, geek2]

The next 2 lines control the parameters of the players’ scores and their y-factor which only allows the paddles to move up and down.

geek1Score, geek2Score = 0, 0
geek1YFac, geek2YFac = 0, 0

Now we’re moving on to the main loop of the game.

‘screen.fill’ makes the screen black.

while running:
	screen.fill(BLACK)

The ‘event handling’ block manages the events only a player can make. Which is either quitting the game or moving the paddles. The block starts with a ‘for’ loop which will iterate all the events from the ‘pygame.event.get’ function.

for event in pygame.event.get():
	if event.type == pygame.QUIT:
		running = False
	if event.type == pygame.KEYDOWN:
			if event.key == pygame.K_UP:
				geek2YFac = -1
			if event.key == pygame.K_DOWN:
				geek2YFac = 1
			if event.key == pygame.K_w:
				geek1YFac = -1
			if event.key == pygame.K_s:
				geek1YFac = 1
			if event.type == pygame.KEYUP:
				if event.key == pygame.K_UP or event.key == pygame.K_DOWN:
					geek2YFac = 0
				if event.key == pygame.K_w or event.key == pygame.K_s:
					geek1YFac = 0

The first indent is a condition that checks if the current event is a ‘QUIT’ event. If it is, the ‘running’ variable is set to ‘False’ which stops the game from running.

Everything after this pertains to the controls. I first want to point out the ‘KEYDOWN’ is when a key is pressed, and the ‘KEYUP’ is when it’s released. Let’s start with KEYDOWN.

So we see that all the keys really do is affect the paddles’ y-factor. ‘W & S’ are the left paddle’s controls and the ‘up & down’ arrows are the right’s. So when ‘W’ or the ‘up’ arrow is pressed, that respective paddle’s y-factor is changed to -1, which makes it move up. Same applies to ‘S’ and the ‘down’ arrow that changes the y-factor to 1.

The ‘KEYUP’ event takes conditions that if any of the listed keys are released, that paddle’s y-factor is set to 0, which means it stops moving.

The next line is for collision detection. This is where that ‘listofGeeks’ we set earlier comes in. We use a ‘for’ loop to iterate both paddles. Pygame has a collision detection function called ‘colliderect’ which represents the invisible rectangle around the game’s objects. It checks for when the ball’s rectangle collides or overlaps with one of the paddles’. The ball and paddle’s rectangles are retrieved in the argument of this function. Since this line starts with ‘if’ that means it’s a conditional checking for the collision. If a collision is detected, the condition runs ‘True’ and it executes the ‘ball.hit’ method which is responsible for making the ball bounce off the paddle.

for geek in listOfGeeks:
	if pygame.Rect.colliderect(ball.getRect(), geek.getRect()):
		ball.hit()

This next ‘update’ is what solidifies the real-time aspect of the ball and paddles. Without this, everything would be motionless.

geek1.update(geek1YFac)
		geek2.update(geek2YFac)
		point = ball.update()

Next block solidifies the point system. We use -1 for geek1’s score so as to differentiate it from geek2’s. You can’t have the same variable for both players. Regardless, when that variable is met, it assigns a point to the respective player.

if point == -1:
	geek1Score += 1
elif point == 1:
	geek2Score += 1

Next 2 lines speak for themselves. It resets the ball when a point has been scored.

if point:
	ball.reset()

The rest of the code in this section displays the paddles, ball, players’ scores, and solidifies the frame rate.

geek1.display()
geek2.display()
ball.display()

geek1.displayScore("Geek_1 : ",
				geek1Score, 100, 20, WHITE)
geek2.displayScore("Geek_2 : ",
				geek2Score, WIDTH-100, 20, WHITE)
pygame.display.update()
	clock.tick(FPS)	

The very last code is standard for Python games. It’s a condition that checks if the game is being run as the main program.

if __name__ == "__main__":
	main()
	pygame.quit()

Entire Code

import pygame

pygame.init()

# Font that is used to render the text
font20 = pygame.font.Font('freesansbold.ttf', 20)

# RGB values of standard colors
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)

# Basic parameters of the screen
WIDTH, HEIGHT = 900, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pong")

clock = pygame.time.Clock()
FPS = 30

# Striker class


class Striker:
		# Take the initial position, dimensions, speed and color of the object
	def __init__(self, posx, posy, width, height, speed, color):
		self.posx = posx
		self.posy = posy
		self.width = width
		self.height = height
		self.speed = speed
		self.color = color
		# Rect that is used to control the position and collision of the object
		self.geekRect = pygame.Rect(posx, posy, width, height)
		# Object that is blit on the screen
		self.geek = pygame.draw.rect(screen, self.color, self.geekRect)

	# Used to display the object on the screen
	def display(self):
		self.geek = pygame.draw.rect(screen, self.color, self.geekRect)

	def update(self, yFac):
		self.posy = self.posy + self.speed*yFac

		# Restricting the striker to be below the top surface of the screen
		if self.posy <= 0:
			self.posy = 0
		# Restricting the striker to be above the bottom surface of the screen
		elif self.posy + self.height >= HEIGHT:
			self.posy = HEIGHT-self.height

		# Updating the rect with the new values
		self.geekRect = (self.posx, self.posy, self.width, self.height)

	def displayScore(self, text, score, x, y, color):
		text = font20.render(text+str(score), True, color)
		textRect = text.get_rect()
		textRect.center = (x, y)

		screen.blit(text, textRect)

	def getRect(self):
		return self.geekRect

# Ball class


class Ball:
	def __init__(self, posx, posy, radius, speed, color):
		self.posx = posx
		self.posy = posy
		self.radius = radius
		self.speed = speed
		self.color = color
		self.xFac = 1
		self.yFac = -1
		self.ball = pygame.draw.circle(
			screen, self.color, (self.posx, self.posy), self.radius)
		self.firstTime = 1

	def display(self):
		self.ball = pygame.draw.circle(
			screen, self.color, (self.posx, self.posy), self.radius)

	def update(self):
		self.posx += self.speed*self.xFac
		self.posy += self.speed*self.yFac

		# If the ball hits the top or bottom surfaces,
		# then the sign of yFac is changed and
		# it results in a reflection
		if self.posy <= 0 or self.posy >= HEIGHT:
			self.yFac *= -1

		if self.posx <= 0 and self.firstTime:
			self.firstTime = 0
			return 1
		elif self.posx >= WIDTH and self.firstTime:
			self.firstTime = 0
			return -1
		else:
			return 0

	def reset(self):
		self.posx = WIDTH//2
		self.posy = HEIGHT//2
		self.xFac *= -1
		self.firstTime = 1

	# Used to reflect the ball along the X-axis
	def hit(self):
		self.xFac *= -1

	def getRect(self):
		return self.ball

# Game Manager


def main():
	running = True

	# Defining the objects
	geek1 = Striker(20, 0, 10, 100, 10, GREEN)
	geek2 = Striker(WIDTH-30, 0, 10, 100, 10, GREEN)
	ball = Ball(WIDTH//2, HEIGHT//2, 7, 7, WHITE)

	listOfGeeks = [geek1, geek2]

	# Initial parameters of the players
	geek1Score, geek2Score = 0, 0
	geek1YFac, geek2YFac = 0, 0

	while running:
		screen.fill(BLACK)

		# Event handling
		for event in pygame.event.get():
			if event.type == pygame.QUIT:
				running = False
			if event.type == pygame.KEYDOWN:
				if event.key == pygame.K_UP:
					geek2YFac = -1
				if event.key == pygame.K_DOWN:
					geek2YFac = 1
				if event.key == pygame.K_w:
					geek1YFac = -1
				if event.key == pygame.K_s:
					geek1YFac = 1
			if event.type == pygame.KEYUP:
				if event.key == pygame.K_UP or event.key == pygame.K_DOWN:
					geek2YFac = 0
				if event.key == pygame.K_w or event.key == pygame.K_s:
					geek1YFac = 0

		# Collision detection
		for geek in listOfGeeks:
			if pygame.Rect.colliderect(ball.getRect(), geek.getRect()):
				ball.hit()

		# Updating the objects
		geek1.update(geek1YFac)
		geek2.update(geek2YFac)
		point = ball.update()

		# -1 -> Geek_1 has scored
		# +1 -> Geek_2 has scored
		# 0 -> None of them scored
		if point == -1:
			geek1Score += 1
		elif point == 1:
			geek2Score += 1

		# Someone has scored
		# a point and the ball is out of bounds.
		# So, we reset it's position
		if point:
			ball.reset()

		# Displaying the objects on the screen
		geek1.display()
		geek2.display()
		ball.display()

		# Displaying the scores of the players
		geek1.displayScore("Geek_1 : ",
						geek1Score, 100, 20, WHITE)
		geek2.displayScore("Geek_2 : ",
						geek2Score, WIDTH-100, 20, WHITE)

		pygame.display.update()
		clock.tick(FPS)	


if __name__ == "__main__":
	main()
	pygame.quit()

@grchab

#python #learnpython #pythonfunction #pythonfunctions #learnpythonprogramming #learntocode #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

@grchab

Extra example from Python 13; full post on blog #python #learnpython #pythonfunction #pythonfunctions #learnpythonprogramming #learntocode #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

Functions are first defined with a ‘def’, followed by a name, then with parameters (or ‘arguments’, they’re the same) wrapped in parentheses.

def f(a, b):

Whatever is in the function body is meant to be executed. In order to execute the function, you have to call it. To call the function, you type its name along with all the arguments. The only case you don’t have to call all the arguments is if the one you’re not calling has a default value.

If you want to print something from within a function, you can use the ‘print’ keyword in the body so you don’t have to use it again to execute it. All you do then is call the function.

def hello_sir():
  print("Hello sir!")
hello_sir()

Output: Hello sir!

Again, since we already have the ‘print’ inside the function’s body, we don’t need to ‘print’ again to get it to show in the output. Calling the function will execute that ‘print’ for us.

A function allows us to change a bunch of things at once. Let’s say I want that string to print multiple times, and instead of using the function, I just printed that string by itself. If I wanted to change that exclamation point into a period, I’d have to go in and change each string into that period. In the real world there can be hundreds of the same string.

The flip way of doing this would be to use a ‘return’ statement.

def hello_sir()
  return "Hello sir!"

print(hello_sir())

Output: Hello sir!

Ignore the ‘print’ for a minute. One overwhelming aspect of programming in general is you’re not always gonna get direct feedback on what you’re doing. So with this ‘return’ statement and its string, if I didn’t have the ‘print’ there and thus with the output, there would be nothing telling you that you did this right. There’s no real tip for this, you just gotta used to working in the dark. Understand as long as your ‘return’ is there, the function is holding whatever you put into it.

So that’s working with strings. For basic arithmetic, I pretty much got it. The use of ‘result’ is one thing that tripped me up.

def g(y):
    return y*5

print(g(10))

or

def g(y):
    result = y*5
    return result

print(g(10))

Output: 50

For this basic multiplication problem, returning the equation by itself will still run. So ‘result’ is unnecessary in this case. To go over this again, this also works if you have multiple arguments,

def h(a, b, c):
    return a + b

print(h(1, 2))
print(h(5, 7))

Output: ERROR

just make sure you have a value for all the arguments. This code would run as an error because there is no value for ‘c’. The only way we could make this run without adding a third value to those prints is to give ‘c’ a default value. We’ll give it 23.

def h(a, b, c=23):
    return a + b

print(h(1, 2))
print(h(5, 7))

Output: 3  12

It’s like 2 older siblings who want to go out but they have to bring the baby along. The default value is a toy for the baby so it doesn’t feel left out. Even if I added a third value to those prints, since ‘c’ has its default value, that third value will still be ignored.

And remember, even if we remove the prints and leave the function calls, it will still compute the equations, you just won’t see it in the output.

When it comes to returning a variable within a function, there are 2 ways:

def make_greeting(name):
    greeting = "Hello, " + name
    return greeting
-----
greeting = make_greeting("Alice")
print(greeting)
greeting = make_greeting("Bob")
print(greeting)

or

print(make_greeting("Alice"))
print(make_greeting("Bob"))

Output: Hello Alice  Hello Bob

The first one sets the variable to call the function and assign a value to its argument, which is “Alice” and “Bob” to ‘name’ in this case. In the second way, we directly print the function call and those values. The output is the same for both ways. The second way looks much cleaner, but we can’t completely dismiss the first way. I don’t yet know how, but it may be the better method for a certain situation.

There’s also a third way where we could define the names in separate variables, then assign the function to those variables:

name1 = "Alice"
name2 = "Bob"

def make_greeting(name):
    greeting = "Hello, " + name
    return greeting

print(make_greeting(name1))
print(make_greeting(name2))

Output: Hello Alice  Hello Bob

This way actually ignores the ‘name’ argument and lets the top variables take its place.

I know I’m going in circles. The point of me doing this is to show there are multiple ways of getting the same result. Again, just because one takes less typing, it doesn’t mean the other ways are useless.

We’re gonna do another 2-method problem that involves using a built-in function with a custom function.

def square(number):
    return number * number

length = len("Alice")
print(square(length))

vs

def square_length(string):
    length = len(string)
    return length * length

print(square_length("Alice"))

Output: 25

Our goal for this is to print the length of the string “Alice” multiplied by itself. Since “Alice” is 5 letters, that’ll be 5*5 which is 25. The first code returns the argument ‘number’ multiplying it by itself. It then leaves the body and sets a variable ‘length’ to equal the length of the “Alice” string, using the ‘len’ function. Finally, it calls the function with the ‘length’ variable which computes the multiplication. With the second code, the function is defined to perform the length equation. The first code, we do it like it was given as an extra instruction. In the second code, the function is defined like the equation was the main instruction.

With these examples, it seems as if you can either perform your operation in the function’s body, and just call it, or define the function, then do all the work outside the body. I seek to understand why it would be one way and not the other, outside of readability.

So this is my little recap of Python functions. It’s essential to everything that follows with this language. My big takeaway from this was familiarizing myself with different ways of getting the same result. I know there’s a lot more we can do with functions, this is just me getting reacquainted with them.

@grchab

Part 1/2 of Calculus 2; full post on blog #calculus #algebra #logarithm #logarithms #exponent #exponents #learnmath #learnmathontiktok #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

@grchab

Part 2/2 of Calculus 2; full post on blog #calculus #algebra #logarithm #logarithms #exponent #exponents #productrule #quotientrule #powerrule #learnmath #learnmathontiktok #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

So like in my Computer Science #4 post, I went over logarithms, but let’s refresh on exponents first.

In mathematical notation (the way of writing a number), exponents are a symbol that represents the repeated multiplication of a number by itself. If I want to write 3 x 3 x 3 x 3, without taking up space, I would write 3⁴. If you’re multiplying the same number twice, to the second power, that’s known as ‘squared’. If you’re doing it three times, to the third power, that’s known as ‘cubed’. To the first power means the number is by itself, there’s no multiplication. Any number to the power of 0 is ALWAYS 1.

My 12th-grade pre-calc teacher told us that at her final math exam in college, the professor came in. You know those old-school chalkboards that take up the whole wall. He wrote an equation that took up the whole width of that board. Dozens of numbers. She said everybody was stressing trying to break down the equation. Some people were using pages of scratch paper. She recognized the equation started with an open parenthesis, and ended with a closing one, topped off with that tiny superscript 0 right after it. To that point, she wrote a simple 1 on her paper and turned it in. Her classmates thought she gave up. I don’t think she was the only one, but she was one of the few students of an upper-level college math class, to pass that final exam. No matter how many digits they throw at you, ANY number, to the power of 0, is 1.

A logarithm is another notation symbol we can use to express big numbers. It’s not only for this, but we can look at it as a reverse for exponents. If I have 8⁵, which is 32768, in logarithmic form, we write log subscript the base number, then result, which equals the exponent. So 8⁵ as a logarithm would be log₈(32768) = 5. If you want to know the result of a number raised to a power, you’d use exponents. If you have the result and the base number but want to know the power it’s raised to, you use logarithms.

Here’s the formula using variables: log_b(a) = c ~ b^c = a

a is the argument (the result of the exponent), b is the base number, and c is the exponent

If you don’t put anything as b, it will default to 10. This is known as a common logarithm

We know that log₂(8) = 3, but what if I wanted log₂(1/8)? It would be -3. When you add dividend 1 over the argument, the positive exponent turns negative.

This really gets messy when the argument is lower than the base, especially when it’s a fraction. If we got log₈(1/3), the result would still be in logarithmic form.

Properties

There are 4 properties of logarithms: product, quotient, power, and change of base rule.

The product rule [ log_b​(MN) = log_b​(M) + log_b​(N) ] is when we have multiplication as the argument. Say we have log₂(4 * 8), which is 32. We first expand the factors into separate logarithms and add them, log₂(4) + log₂(8). The first’s exponent is 2, and the second’s is 3, which equals 5. So once we multiply the argument and solve the logarithm, we see that 2⁵ = 32. The same applies that if you start with 2 separate logarithms, you’d have to condense them. And keep in mind this only works if the bases are the same. We’ll get to different bases later.

The quotient rule [ log_b​(N/M​) = log_b​(M) − log_b​(N) ] is the inverse of the product rule. If the argument is a division problem, you separate them and subtract.

The power rule [ log_b(M^p) = plog_b(M) ] is when the argument has an exponent and you switch it to in front of the log to multiply it, which gives the same result. log₄(4²) = 2log₄(4)

Lastly, the change of base rule is used when the argument doesn’t fit the base as a whole number. If I have log₂(50), no regular exponent of 2 goes into 50, so the resulting exponent would be messy. This isn’t always the answer, but usually it’s best to change the base to 10 so it’s easier to work with. Then we split the logarithms into a division problem with our new base 10. The argument stays the same for the numerator, and the original base becomes the argument for the denominator. the result would be a decimal, about 5.64.

@grchab

#python #learnpython #learntocode #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

I have finished the pythonprinciples.com course! I didn’t do the last project since I would just be doing it to do it. I wouldn’t be solidifying much. If this was a formal class, I’d technically be certified by now, but I’m still incompetent. So I need to make sure I know what I’m doing.

First, if you would like to run something through Python without downloading a software, I recommend online-python.com. I don’t know about running a whole program through it, but it’s great for testing a piece of code without a bunch of technicalities. So if you want to test your chops, go ahead to that site.

So now that this is done, I first need to go back over what I struggled with. So I’m gonna give a basic overview of what I learned in Python.

Python is made up of types like integers, strings, booleans, lists, tuples, and dictionaries. You can cast these types which is another way of saying invert one into another. You got built-in functions and user-defined ones. These functions are used to manipulate the types to make them perform certain tasks and operations. These operations include basic arithmetic math, sequencing, modifying lists and sequences, looping, conditionals and comparisons, along with a plethora of data manipulation tactics.

Functions and loops are the biggest things I struggled with. I got through the tasks, but I still don’t understand the full scope of what they’re capable of. So I’m gonna be diving deep into those. I’ll be doing a few exercises from a variety of platforms.

Past that, I’m gonna throw myself into the fire and start doing projects. My next step now is to just do a project, as basic as can be, and then do some more versatile ones.

Since data science and engineering is my field, I’m gonna start with one of those. That’ll be in my data posts.

Outside of data, I will eventually be doing a regular Python project, but it’s better if I focus on my field first and not spread myself too thin.

So again, my first data project with Python will be in my data posts.

For the Python posts here, I’ll be reviewing the concepts I struggled with. Starting off, that’ll be functions and loops.

How will I be reviewing these? I’ll go back over some of the tasks from pythonprinciples.com. I also have a Reddit post here with a handful of sites I can practice with. I won’t be choosing just one site. The idea is to be able to complete any of the tasks in all of them, which will show I understand the concept for itself, and not for doing it for the sake of getting through it.

So next Python post, I’ll be going back over functions

@grchab

2nd half is in 1.2; Full post on Algorithms #1 on blog #algorithm #algorithms #clrs #datascience #insertionsort #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

The base of all technology is it speeds up a process we used to spend time on, and gives us freedom to do higher-level things. Algorithms are the premier technology of information.

Algorithms are computational procedures. They take an input and process it to generate an output.

So to study this, I’ll be reading Introduction to Algorithms, better known as ‘CLRS’. This is by far my biggest conquest for data science. It’s a multidisciplinary, almost grad school-level textbook. Since I’m a beginner, I’ll have to break each discipline down to size and learn how they all tie into algorithms. It’s intimidating, but I’m eager to conquer this thing.

I’ve only read the first 2 intro chapters on analyzing and designing algorithms. Past those, I’ll be stepping away to educate myself on the other disciplines. So starting off, I’ll summarize what I learned in the first 2 chapters.

The most fundamental algorithm is sorting. If I have a sequence of numbers that I input into a sorting algorithm, it will output those numbers in a particular order, usually from least to greatest. This type of output is called a permutation which is the reordering of a sequence.

After an algorithm does its job, it halts, meaning it ceases operation to which it then presents the output. Some algorithms are incorrect, meaning they halt before their full operation. Yet some incorrect algorithms can suffice if we can control their error rate, but we’ll get to that later.

In a perfect world, algorithms run when all the input data is available. In reality, input data arrives over time. The algorithm has to decide how to proceed without having all the data, and without knowing what new data will be coming.

If algorithms are cars, computing power is gas. Different algos have different mileages and we have to know when it’s appropriate to use more or less. So resourcefulness will be a big quality we have to practice.

And there are time complexities in this field which not only means how long algorithms take to run, but how they grow and adapt to incoming inputs.

So again, sorting is most basic type of algorithm. The sequence is made up of keys, usually numbers. The process works by taking a number and testing its relationship with another number, to see if it’s less or greater. Each time it does this is called an iteration. For each iteration, a loop invariant is applied which ensures the current and previous are both correct

There are 3 steps a loop invariant goes through:

1. Initialization – It is true prior to the first iteration of the loop
2. Maintenance – If it’s true before an iteration, it remains true before the next iteration
3. Termination – The loop terminates, and when it terminates, the invariant gives a useful property stating why the algorithm is correct

As long as the first 2 hold, the loop invariant will be true prior to every iteration.

A loop-invariant proof is a form of mathematical induction, where to prove that a property holds, you prove a base case and an inductive step. Initialization is the base case, and maintenance is the inductive step

Typically for the termination property, we use a loop invariant along with the condition that caused the loop to terminate. Inductions usually run infinitely, but with a loop invariant, it stops when the loop terminates.

@grchab

2nd half of 1.1; Full post on Algorithms #1 on blog #algorithm #algorithms #clrs #datascience #insertionsort #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

Analyzing Algorithms

Analyzing mostly means determining the resources needed for the algorithm. Mainly memory, bandwidth, energy consumption, and computational time.

Outside the algorithm itself, the computer it’s running on can affect its computational time. Even with the same algorithm, the input can affect the time. The obvious factor is the size, 100 numbers would take longer to compute than 3 numbers. But even if the inputs are the same size, one can take longer if it’s not already as sorted as the other.

This (5, 7, 2, 1, 8) would take longer to sort than this (2, 5, 1, 7, 8) even though they have the same keys.

For measuring input size, outside of (obviously) counting the number of elements, there’s also the number of bits needed to represent the input in binary notation.

Running Time

Running time is measured by the number of instructions and data accesses executed. Again, depending on the computer, this may not be constant. Some lines may execute at different times. An algorithm’s running time is the sum of the times for each statement executed

For an insertion-sort, best case it’s a linear function, average or worst case it’s a quadratic function.

Order of growth is how the running time increase with the input.

Designing Algorithms

There are a number of techniques for designing an algorithm. We’ll start with divide-and-conquer.

Not most, but many algorithms are recursive, meaning they’ll call themselves to break a larger problem into subproblems. It divides the problems up, conquers them, then brings them back together to solve the main problem.

For these subproblems, we can evaluate their runtime by a recurrence equation. This can help us set bounds to predict an algorithm’s runtime and overall performance. And there’s also a recursion tree that we use to illustrate these steps.

So that’s it for the first 2 chapters. I know that was very general. This is a multidisciplinary textbook so I’ll need to brush up on my other subjects before I move on. I had ChatGPT list the concepts I’ll need to know as a beginner.

1. Foundational Concepts:
   • Basic Data Structures (Arrays, Linked Lists, Trees, Graphs)
   • Algorithm Analysis (Time Complexity, Space Complexity, Big O Notation)
   • Asymptotic Notations (Big O, Omega, Theta)
2. Next Level Concepts:
   • Sorting Algorithms (Quicksort, Mergesort, Insertion Sort, etc.)
   • Searching Algorithms (Binary Search, Linear Search)
   • Recursion and Recursive Algorithms
   • Mathematical Foundations (Summations, Logarithms, Mathematical Induction)
3. Algorithm Design Techniques:
   • Divide and Conquer (e.g., Merge Sort, Binary Search)
   • Greedy Algorithms (e.g., Huffman Coding, Dijkstra’s Algorithm)
   • Dynamic Programming (e.g., Fibonacci Sequence, Longest Common Subsequence)
   • Backtracking (e.g., N-Queens Problem, Sudoku Solver)
4. Advanced Algorithm Analysis:
   • Amortized Analysis
   • Randomized Algorithms
   • Parallel Algorithms
5. Complex Data Structures and Advanced Topics:
   • Advanced Tree Structures (AVL Trees, Red-Black Trees, B-Trees)
   • Graph Algorithms (Shortest Path Algorithms, Network Flow)
   • String Algorithms (Pattern Matching, String Compression)
6. Advanced Mathematical Concepts:
   • Discrete Mathematics (Graph Theory, Combinatorics, Number Theory)
   • Linear Algebra (Matrix Operations, Eigenvalues, Singular Value Decomposition)
   • Probability and Statistics (Probability Distributions, Hypothesis Testing)

So next post, I’ll be starting with data structures.

@grchab

#computerscience #byte #bytes #hexadecimal #ascii #morsecode #computerengineering #computerhardware #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

So far we’ve been dealing with minimal bits that can only make simple statements. A circuit that can deal with multiple bits is almost a computer

A group of bits to a computer is a word. These word lengths are described as 6-bit, 8-bit, 24-bit, or any number. Even though bits exist, that’s way too small a unit for practical use, just how we don’t we describe all amounts of money as ‘cents’. In comes the byte which is 8 bits. A byte is the standard unit of digital data. A bit is a cent, a byte is a dollar. There’s also a half-byte called nybble, which is 4 bits, but it isn’t as common as a regular byte; this is the 50 cents of byte.

Since it’s 8 bits, it consists of 8 digits, but not in the decimal number system we’re used to; it’s not the same as an 8-figure number like 10,000,000. A byte can take on binary values from 00000000-11111111, which can represent decimal values from 0-255. 2 bytes would be a byte squared (256²) which jacks that up to 65,536 decimal values.

To recap, we use binary and other alternate number systems to represent values for the computer. Of course for us humans, the decimal ‘0-9’ system works just fine, but for the computer and all the numbers it has to process, that would get extremely messy. I don’t like unnecessarily complicated things either, but over time, you’ll see why we use these alternate number systems.

Bytes use a hexadecimal (base-16) system. 0-9 are still what they are, but after that it goes to letters A-F, which represent decimal 10-15. I know using letters as numbers don’t make this any simpler, but we gotta get used to it. After that, it then goes to hexadecimal 10, which is 16 in decimal. It’ll then finish off those double digits up to 19; hex 11 is dec 17, hex 12 is dec 18… and hex 19 would be dec 25. After that, it goes to hex 1A, which is dec 26, and the pattern continues. So hex digits will go 0-9, A-F, 10-19, 1A-1F, 20-29, 2A-2F, and so on.

If you’ve ever taken a basic graphic design or digital illustration course, you’ve seen hexadecimal used in RGB (red green blue) to represent colors, since all colors have a certain amount of red green blue in them.

For formatting, we write long binary numbers with a space/dash in between every 4 numbers. looking at 00001111 like this is much more antsy then viewing it like 0000 1111.

Computers don’t recognize anything by default. If you want to do something with a thing, you have to first tell it that thing exists. This even applies to plain texts like you’re reading right now. Computers recognize this text through an ASCII code

In Morse code, ‘E’ is a dot, ‘T’ is a dash, but ‘A’ is a dot and dash. Since ‘A’ uses those 2 characters that mean something else by themselves, that makes Morse code a variable bit-length code; it reuses the same characters for different representations.

In the old days, there was a code called Baudot that was used for telegrams. It used dots and spaces like Morse code. Up until the 1960s, there was a new code called ASCII. It can be converted between binary or hexadecimal. As to what the computer reads it as I can’t yet say.

@grchab

#computerscience #binary #binarynumbers #bits #logarithm #logarithms #computerengineering #computerhardware #learninpublic

♬ original sound – Curiosity Corner 🙇🏽‍♂️

I’ve replaced the first edition of CODE by Charles Petzold, which came out in 1999, with this newer edition which came out this past August in 2022.

There are a few improvements in the early chapters. Like in the old one it says telephone, in the new one it says cell phone. But the concepts are still the same, so there’s nothing worth me going back over it.

I read the first 10 chapters. All it went through was the structure of minimal languages, specifically Morse code, braille, and binary numbers. Then it takes you through Boolean algebra and logic gates. I don’t feel like going back over those. So if you’re that interested in them, just go read the first 3 computer science posts on my blog. I’m gonna pick up where I left off in chapter 11.

Morse code and binary numbers are both binary languages; bi-nary, meaning they’re ‘of 2’. All of Morse code is an arrangement of dots and dashes. All of binary number language is arranged of 0s and 1s. Braille isn’t exactly binary, it’s strictly made of dots. It can only go up to a 3×2 arrangement. So there are a lot more combinations in that compared to Morse and binary, but it’s still a fairly minimal language. Compare those 3 to the English alphabet where we got 26 letters.

Now all those little pieces of those languages, the dot and dash of Morse, the 0 and 1 of binary, or even each of the letters of the alphabet, are considered bits. A bit is the smallest unit of information possible. Just as a penny is the smallest unit of money.

In this old poem called Paul Revere’s Ride, he made a basic system of lighting 1 or 2 lanterns to alert the American colonies if the British were invading. The famous line, “One if by land, two if by sea”

Now the land and sea are the only conditions of this situation. If all they cared about was whether the British were coming or not, they’d only need one lantern, yes or no.

So in the realm of electronic communication, the more conditions you add, the more bits we have to use.

Look at phone numbers, starting with area codes. There are 10 numeral digits, 0-9. An area code has 3 digit places. So all possible area codes are between 000-999, a total of 10³, 1000 area codes. Once you set an area code, there are 7 more digits to go. That’s a total of 10,000,000, or 10⁷ possible numbers after that one area code.

The same goes for binary code. Starting off there’s only 1 bit that represents 2 values, 0 and 1. Every time you add a bit, those values double. So 2 bits would represent 4 values, 00, 01, 10, 11. 3 bits represents 8 values, 4 bits reps 16, 5 bits reps 32 and so on.

Now in terms of the total values, each bit would represent the power of that total. Again, 1 bit is 2 values, so that would be 2¹. 2 bits is 4 values, so that’d be 2² and so on.

So what if we already knew how many values we have, but don’t know how many bits there are? To solve this we’d use a base-two logarithm, remember binary code uses the base-two number system. Let’s say we have 128 values. We first click ‘log’ and parentheses will pop up. We input our total values, which is 128, then we divide that, click ‘log’ again and input ‘2’ so it knows we’re using the base-two system. Equal that, and our answer is 7, which means that 128 is the result of 2⁷.