Beginners Python Programming - Learn By Coding Games

Computer programs basically revolve around data. They collect data, store it, manipulate it and output it. Every piece of software you can think of is carrying out these tasks.

As data is so vital to our code we need to know how to store it inside our program so that we can work with it.

This is where variables come in.

In this lesson we'll learn what variables are, how to create them, how to store data in them and how to manipulate and change that data.

So far we've been typing or Python commands into the console. But this only lets us execute one program statement at the time. Computer programs need a large number of instructions executed one after another.

In this lesson will learn how to use the Mu editor to create a program, save it and run it.

Once a computer program has gathered some data we need to analyse it and make decisions based on our findings. This allows a code to take different actions depending on the values of our variables.

In this lesson we learn about the main conditional statement in Python, the IF statement. We'll learn how to create Boolean expressions using, and comparing variables and then see how the IF statement can be used to control which blocks of code are executed.

Sometimes our code needs to repeat a block of statements over and over again. Instead of writing out our statements multiple times, we can use looping structures to repeat a single block of code as many times we want.

In this lesson will learn about the FOR loop and use the RANGE function to control its operation.

Our simple guessing game needs to let the user have a number of goes at guessing the word. In this lesson will use our looping skills to add a FOR loop to achieve this. We'll also see how we can use the BREAK command to jump out of the loop before it's finished.

For our second game we're going to write a text based version of noughts and crosses (or tic-tac-toe).

To begin with I'll describe how the game works (just in case you don't know!) and then cover a few of the basic programming techniques you will need to complete the project. This will include an expansion of the IF statement using both the ELSE clause and the Python ELIF statement (ELSE IF).

If you've already got some programming experience this is a good project to try to complete by yourself. After covering the major ideas I'll give you a chance to have a go by yourself.

If you've only got a little bit of programming experience I'll give you an overview of how to solve the problem so you can have a go at creating the code by yourself.

If you are not yet ready to programme on your own the next lesson is will cover the whole solution step-by-step.

In this lesson I'll take you through the complete solution for the noughts and crosses game.

We'll start with a completely blank project and then build the code line by line so you can see how we turn the algorithm for how the game works into actual Python code. By the end of the lesson will have a fully working version of the game using only the programming techniques we've covered so far in the course.

The code we created in the previous lesson works, but it's not a very elegant solution. A number of blocks of code are repeated throughout the programme which is bad programming practice.

In this lesson will learn how to pull blocks of code out of the main program and placed them in two things called functions. These functions then allow us to execute these blocks of code simply by calling them by name. Instead of repeating blocks of code that have been typed into our program listing, we simply call the function whenever it's needed.

Using functions is one of the main building blocks in being able to write well structured code. Without this skill you'll find it almost impossible to write more complex programs.

One of the great features of modern programming languages, including Python, is the availability of code packages. Packages are blocks of code written by somebody else that you can bolt onto your code to instantly give you a whole range of new features to use in your program.

In this lesson we'll move away from text based software and start graphic programming. For this we'll need to use a package called PyGameZero. PyGameZero is pre-installed by the Mu editor, but I'll show you where you can get hold of other packages and how you install them for future use.

We'll then start using PyGameZero to create a window for our game and learn how to use the documentation to find out about the features of a package and how we can apply them in our code. By the end of the lesson we'll be able to draw primitive shapes inside our game window.

Now that we've got a static square being drawn in our game window we need to make it move.

In this lesson we'll see how we can model our square using variables, and then by adjusting these variables make it move around the screen.

We'll also be looking at the idea of global and local variables in our code. So far we've been assuming that if we create a variable we can use it anywhere we want. Once we start using functions this is no longer the case. I'll show you the difference between global and local variable scope and we'll then work out how to make sure our code understands what we're trying to do.

We can now move the square on screen so let's expand upon that and get it bouncing around inside our game window.

We'll learn how to control the speed and direction of our square and how to detect when it has collided with the sides of the window.

Our bouncing box code uses a number of discrete variables to model the actual box and its position on the screen. If we had to model a number of different objects we'd end up with lots of discrete variables lying around inside our code. As our code gets more more complex this will just get incredibly confusing.

We need a way of packaging the data that represents a particular object into one place. This is where objects come into play.

In this lesson you will learn how to specify a CLASS which can then be used to create, or instantiate, an OBJECT. This can then be stored in a variable. These objects can contain both data and code and allow us to model various parts of our software and encapsulate it all within a single data entity.

This is your first step towards Object Orientated Programming, OOP.

We've now built a class to model a single box. We also know how to instantiate an object using this class which can be stored in a single variable. This object has the ability to move and draw itself using simple commands or methods.

Once we have the ability to create one object we can create as many as we want. We can use loops to repeatedly generate new objects but we need a better way of organising them so we can work with them as a group.

In this lesson we learn about lists, arrays and tuples and how we can store multiple variables inside these data structures.

By the end of this lesson our code will be able to generate as many boxes as we want and control all of them as they bounce around the screen.

We've now had a play with some smaller programs whilst we learnt the basic programming techniques will need for larger projects.

So let's get started on a proper game.

In this lesson we'll have a look at the Snake game project and get ready to start coding it.

The Snake game is going to be a fairly complex piece of software. There are a lot of things happening as the game progresses and the number of game characters that need to be modelled and animated. When we tackle projects like this we need to break them up into smaller, manageable pieces. As we solve and code each of the smaller problems we can put them together to create the finished game.

In this lesson we will go through a top-level design to try to identify a number of objects that we'll need to code to manage our game characters.

Before we can start the game we need to create a game area and be able to prompt the user to start the game.

In this lesson we will learn how to detect keyboard presses and react to them. We'll also build in the major game states: the start screen, the game playing state and the endgame screen.

We'll also learn how to add graphics to our game by downloading an image and using it on our start screen together with some properly aligned text in a font of your choice.

The game screen needs a number of fixed objects and text for things like the player score, play area outline and other game information - usually called boilerplate.

In this lesson we'll learn how to use program constants to define a number of parameters for our game. Our game display will then use these constants to calculate the sizes and positions of areas and objects within our game. This allows us to easily make adjustments to the layout of the screen without having to alter our code.

By the end of this lesson our game screen will be ready for the actual game characters and will be fully controllable using our newly created constants.

The first character we need to animate is the snake itself.

In this lesson we will look at how the snake moves and develop a grid system to control its position on the screen. We'll then build this grid system into our screen layout code so that we can easily specify a size for our active play area and have our screen automatically adjust itself to accommodate this.

In this lesson we'll learn how to animate the snake's head.

We'll be starting to code the main snake class that will encapsulate the data and code needed to model the snake character. We'll learn how to convert between the snake's grid and the actual pixels on the screen and then how to control the speed of the snake by adding a delay timer into the snakes move method.

Now that the snake is moving we need to add the player controls.

In this lesson will learn how to detect key presses and then decode these to control the direction the snake moves in. We'll also build in the code to stop the snake backtracking on itself as later in the game this would cause an instant death.

By the end of this lesson the player will have full control over the snake movement.

So far the snake has just been a single square moving around the screen. We need to add more body parts and have those follow one after the other, tracing the same track as the head of the snake.

In this lesson will create a separate class to model an individual snake body part and then see how we can use a Python list within our main snake class to store and control the individual body parts as one whole snake.

At the end of this lesson we will be able to create a snake of any length and have it slither around the screen.

When we created our screen display we put a green box to mark the limits of the active play area. If the snake tries to go outside this area it dies.

In this lesson will be adding limit detection to the snakes movement so that our code can detect when the snake has moved outside the active play area. If this happens our code will kill the snake and take us to the endgame state.

The game objective is to grow the size of the snake by eating food.

In this lesson we will start building our food classes to model both individual piece of food and to create an overall food handling class. Food needs to be generated using a random timer and each piece of food will stay on screen for a random length of time. Our food code therefore needs to have built in timers to control these events.

By the end of this lesson we will have food randomly appearing in the play area, staying there for a random time, and then disappearing.

For our snake to be able to eat food our code needs to detect when the snake's head has collided with one of the food objects.

In this lesson we'll learn about bounding box collision detection and how we can model our objects as rectangles to make it easy to calculate when they have collided. We'll code our own collision detection software and then use that to allow our snake to eat the food.

When our snake eats food it should start to grow.

In this lesson will use the collision detection from the previous tutorial to trigger a new block of code that will add body segments to the tale of the snake. The number of body segments each piece of food generates will be built into the food object, and this data will be transferred through the objects to the snake object so that it can grow the snake.

By the end of this lesson you will understand how data can be fed into and out of objects using parameters and return values.

At the moment the only way the snake can die is to crash into the edge of the playing area.

In this lesson will write the code to detect if the snake's head is collided with another part of its body. If this happens we will kill the snake.

As the game progresses we need to increase the game difficulty. One way we can do this is to increase the snake speed as it gets longer and longer.

In this lesson will write code to monitor the length of the snake and then adjust its speed accordingly. We'll also learn how to translate the speed value into a meaningful number that can be displayed to the player.

By the end of this lesson are snake speed will automatically increase as our snake gets longer and longer.

Signed adds to the atmosphere of the game. At the moment our game is completely silent.

In this lesson will add sound effects and backing music to the snake game. You'll learn how to use PyGameZero's built in sound objects to generate simple tones, and then to import pre-recorded sound effects which we can play to mark certain events in the game such as hitting the edge of the screen, eating food, etc.

We'll also learn how to add background music and how to control its playing as we move between the start, play and endgame states.

When the snake dies we simply leave all of our variables and objects at the same state as when the game ended. If we try to restart the game it doesn't work.

In this lesson we learn how to write code that will both initialise the game at the very start, but also reset it back to its starting values when we want to play a second game. This will involve re-factoring (reworking) some of our code to make it more flexible.

By the end of this lesson our game will easily transition from the start screen, through the game playing state, into the end game state and then back to the playing state.

A game can never have too many things that kill you!

In this lesson we'll design spiders for our game. We'll work out how they appear and how they move around the screen. This will involve a bit of mathematics but I'll walk you through all the calculations step-by-step.

PyGameZero has a number of built-in objects that we can use to simplify our game code. One of those is the Actor object.

In this lesson we'll reuse part of our food class code to get our spiders appearing on screen using a random timer. We'll then see how we can use the Actor class to model the spider sprite (image) and render the graphic in our game window.

The spiders need to move randomly around the screen, but mustn't go off the edges.

In this lesson we'll implement the algorithms we discussed in the first spider tutorial to control the spider movement. We'll learn how to translate the algorithm into Python code so we can make the spiders travel at any angle we want, and control the speed along that path.

By the end of this lesson our spiders will be crawling all over the screen.

If the snake head hits a spider it dies.

In this lesson we will use the bounding box collision detection built into PyGameZero to detect when the snake head hits a spider.

By the end of this lesson you'll have a fully working, finished, Snake game.

Congratulations on completing the course.

Let's take the next step!