Skip to content

Glossary

This glossary lists every technical term used on this site, in alphabetical order. Each term links to the page where it is first explained. Each page lists its new terms in a Terminology callout at the top. Terms already introduced in an earlier tutorial site aren't repeated in those callouts, but they are all listed here.

A · B · C · D · E · F · G · H · I · L · M · N · O · P · Q · R · S · T · U · V · W · X

A

  • abstraction – the OOP principle of hiding the complicated code inside an object so we only need to call its methods. (Introduction)
  • acceleration – a change in speed over time, such as the ship moving faster the longer a key is held. (4. Advanced Movement)
  • annotation – a note added to a plan or diagram that explains what part of it does. (Planning Your Game)
  • API – short for application programming interface, the set of commands one piece of software provides so other code can use it. (Introduction)
  • argument – a value we send into a function or method when we call it. (7. Asteroids)
  • asset – a file the game uses that isn't code, such as an image or a sound. (Get to Know GameFrame)
  • attribute – a quality that every object of a class has, such as a student's name, stored as data inside the object. (Planning Your Game)
  • audio feedback – using sounds to tell the player whether what they just did was good or bad. (Game Design)
  • automate – to make something happen by itself under the computer's control, instead of through the player's input. (6. Zork)
  • avatar – the character or object in a game that the player controls. (3. Spaceship)

B

  • background music – music that plays continuously while the game is running. (Audio)
  • boss – a powerful enemy in a game, often faced at the end of a challenge. (6. Zork)

C

  • Cartesian plane – a flat surface where every position is described by an x and a y coordinate. (8. Moving Asteroids)
  • case-sensitive – treating capital and lower-case letters as different, so age and Age are two different names. (1. Welcome Screen)
  • challenge – something the player has to overcome to win a game. (Game Design)
  • class diagram – a UML (Unified Modelling Language) drawing of a class as a table with three rows: the class name, its attributes and its methods. (1. Welcome Screen)
  • clone – to copy a repository from GitHub onto our computer. (Setup)
  • collision – when two objects in a game touch or overlap. (9. Ship and Asteroid Collision)
  • column – one piece of information that is stored for every row in a database table. (Saving Data with a Database)
  • commit – a saved snapshot of our changes, with a message saying what we did. (Setup)
  • control overload – when a game gives the player so many controls or choices that they feel overwhelmed and less in control. (Game Design)
  • cooldown – the waiting time after a power has been used before it can be used again. (Ship Choice)
  • coordinate – a pair of numbers, such as (x, y), that gives a position on a screen or display. (3. Spaceship)
  • cursor – the object that runs SQL statements on a database. (Saving Data with a Database)

D

  • data structure – a way of organising and storing data so it is easy to use. (14. Lives)
  • database – an organised store of data that is saved permanently, so it is kept after the program closes. (Saving Data with a Database)
  • de-spawn – to remove an object from the game. (7. Asteroids)
  • debugging – the process of finding and fixing bugs in a program. (Design Thinking Flowchart)
  • dictionary – a collection that stores values with names, called keys, so we can look each value up by its name. (14. Lives)
  • docstring – a block of text in triple quotes at the start of a class or method that explains what it is for. (1. Welcome Screen)

E

  • event – something that happens while a program runs, such as a button press or two objects colliding, that the program responds to. (2. GamePlay Room)
  • event handler – the code that responds to a particular event, such as moving the player when they type a direction. (2. GamePlay Room)
  • event loop – the part of an event-driven program that keeps checking for events and runs the matching event handlers. (2. GamePlay Room)
  • event-driven framework – a set folder structure and collection of ready-made classes that we build on, where our code runs in response to events such as key presses or collisions. (Introduction)
  • event-driven programming – a style of programming where the program keeps checking for things to happen and then responds to them. (2. GamePlay Room)

F

  • f-string – a Python string with an f before the quotes that puts the values of variables inside { } into the text. (Goals and Rewards)
  • flag variable – a variable that stores True or False to control part of a program, such as running keeping the main loop going. (10. Laser)
  • flowchart – a diagram that uses shapes and arrows to show each step in a program and how it moves from one step to the next. (2. GamePlay Room)
  • fork – our own copy of someone else's repository on GitHub, which we are allowed to push to. (Setup)
  • four-way movement – movement where the player can only go up, down, left or right, and not diagonally. (Other Game Types)
  • frame – each time the screen is redrawn while the game runs. (4. Advanced Movement)
  • frame rate – how many frames are drawn each second, which in GameFrame is 30. (4. Advanced Movement)

G

  • game clock – a timer that makes every run of the game loop take the same amount of time, so the game runs at the same speed on any computer. (5. Keeping the Ship in the Room)
  • game engine – software that provides the tools needed to build and run games, such as drawing graphics and detecting collisions. (Introduction)
  • game logic – all the code that makes a game work, such as what happens when keys are pressed, when objects collide or when the score changes. (Get to Know GameFrame)
  • game loop – the loop that runs over and over while a game is playing, handling inputs, updating the game and redrawing the screen. (5. Keeping the Ship in the Room)
  • game mechanic – one of the basic rules and interactions that build interactivity and challenge into a game and make it fun to play. (Game Design)
  • Git – the industry-standard version control system, which is free and open source. (Setup)
  • GitHub – a website that stores Git repositories online, syncs them with our computer and adds features for sharing and collaboration. (Setup)
  • GitHub Desktop – an app that lets us use Git and GitHub without typing commands. (Setup)
  • global variable – a variable that can be used anywhere in the program and keeps its value for as long as the program runs. (14. Lives)
  • goal – a clear target that the player is trying to achieve in a game. (Game Design)
  • gravity – a force in a game that pulls objects down, making them fall faster and faster. (Other Game Types)

H

  • hitbox – the invisible rectangle around an object that is used to detect collisions. (9. Ship and Asteroid Collision)
  • HUD – short for heads-up display, the information such as score and lives that is shown on the screen while the game is played. (13. Scoring)

I

  • IDE – an Integrated Development Environment, which is an app for writing, running and fixing code. (Setup)
  • indentation – spaces at the start of a line (four in Python) that show which code belongs to a loop or other block. (Common Errors)
  • index – the number that gives an item's position in a list, starting from 0. (2. GamePlay Room)
  • inheritance – the OOP principle of making a new class based on an existing one, so the new class gets the existing class's attributes and methods. (1. Welcome Screen)
  • instance – another name for an object, describing it as one particular copy made from a class. (6. Zork)
  • instantiation – creating a new object from a class, which runs the class's __init__ method. (6. Zork)
  • interactive challenge – a description of a game as something that has both interactivity and challenge. (Game Design)
  • interactivity – when the player has some control over what happens, because the game responds to the player's inputs. (Game Design)
  • interpreter – the program that reads our code and runs it, such as MicroPython on the micro:bit or Python 3 on the computer. (Using Thonny)
  • IPO table – an Input, Process, Output table that maps out what a system takes in, what it decides and what it does. (3. Spaceship)

L

  • life – one of a limited number of chances a player has before the game ends. (14. Lives)
  • list – a collection of items stored in a set order inside [ and ], with commas between them. (14. Lives)

M

  • maintainable – describes code that is easy for other people, or our future selves, to read, understand and change. (5. Keeping the Ship in the Room)
  • memory leak – when a program keeps using memory it no longer needs, so it uses more and more over time and may slow down or crash. (8. Moving Asteroids)
  • method – a function that belongs to an object or value, written after a dot, such as name.upper(). (Planning Your Game)
  • module – a file of ready-made code that we can import into our program to use its commands. (1. Welcome Screen)

N

  • negate – to change a number to its opposite sign, such as -10 to 10, by multiplying it by -1. (6. Zork)

O

  • object – a thing in our program, made from a class, that holds its own data and has methods that make it do things, such as a motor or a game character. (Get to Know GameFrame)
  • open source – software whose code is freely available for anyone to use, study and change. (Introduction)
  • origin – the coordinate used as an object's position, which for objects with sprites is the top-left corner. (3. Spaceship)
  • override – to replace an inherited method by writing a method with the same name in the child class. (Saving Data with a Database)

P

  • package – an extra library, such as Pygame, that we install so our program can use it. (Using Thonny)
  • pickup – an item in a game that the player collects to get a reward or bonus. (Bonus Pickups)
  • pixel – one of the tiny dots of light that make up a screen or display. (3. Spaceship)
  • placeholder – a simple shape, such as a box with an X, that marks where something will go in a plan. (1. Welcome Screen)
  • platform game – a game where the player runs and jumps between platforms while gravity pulls them down. (Other Game Types)
  • play-testing – getting other people to play our game so we can find out whether it is fun and fair. (Design Thinking Flowchart)
  • power meter – a HUD item that shows whether a special power is ready, active or cooling down. (Ship Choice)
  • power-up – a pickup that gives the player a special ability or advantage, often for a limited time. (Bonus Pickups)
  • push – to send our commits from our computer to the online copy of the repository. (Setup)
  • Pygame – a free, open-source Python library for building 2D games and other interactive graphical programs. (Introduction)

Q

R

  • rectangular collision – a way of detecting collisions by putting a rectangle around each object and checking whether the rectangles touch or overlap. (9. Ship and Asteroid Collision)
  • register – to link an object or event handler to an event, so the program tells it when that event happens. (2. GamePlay Room)
  • repository – a special folder, often called a repo, that stores our project files and the history of every change made to them. (Setup)
  • return value – the value a function or method sends back to the code that called it. (Subgoals)
  • reward – something that makes the player feel good about their effort, such as points, and keeps them interested in challenges. (Game Design)
  • robust – describes code that still works correctly when something unexpected happens. (Goals and Rewards)
  • Room – a GameFrame screen or level where the game takes place and which holds the game's objects. (Introduction)
  • RoomObject – a GameFrame object, such as the ship or an asteroid, that is placed inside a Room and contains game logic. (Introduction)
  • root folder – the top-level folder of a project, which contains all of its other files and folders. (Get to Know GameFrame)
  • row – one record in a database table. (Saving Data with a Database)

S

  • scrolling game – a game where the background moves past the player to make it feel like they are travelling. (Other Game Types)
  • set – a collection of values with no order and no repeats, such as the buttons being pressed right now. (14. Lives)
  • Shell – the panel in Thonny that shows what our program prints and any error messages. (Using Thonny)
  • sound effect – a short sound that plays when a particular event happens in the game. (Audio)
  • spawn – to make a new object appear in the game. (7. Asteroids)
  • special power – an ability the player can turn on for a short time to get an advantage. (Ship Choice)
  • sprite – the image used to show an object on the screen. (Get to Know GameFrame)
  • SQL – short for Structured Query Language, the language used to create, add to and get data from a database. (Saving Data with a Database)
  • SQLite – a type of database that stores a whole database in a single file, which Python can use with its built-in library. (Saving Data with a Database)
  • stack – the layers of tools and technologies that work together to run a program, with each layer building on the one below it. (Introduction)
  • state – the situation a program is in at a particular moment, such as which room the player is in. (10. Laser)
  • streak – the number of times in a row the player succeeds at something, such as shooting asteroids without losing a life. (Game Design)
  • structural comment – a comment that says what the next block of code does, making our code easier to find our way around. (1. Welcome Screen)
  • style guide – a set of rules for how code should be written and laid out so it is easy to read, such as keeping lines to 79 characters or fewer. (10. Laser)
  • subclass – a class based on another class that inherits all of its attributes and methods, also called a child class. (1. Welcome Screen)
  • subgoal – a short-term or optional challenge on the way to the game's main goal. (Game Design)

T

  • table – the part of a database that stores data in rows and columns, a bit like a spreadsheet. (Saving Data with a Database)
  • terminal – the panel in the editor where anything our program prints, and any error messages, are shown. (8. Moving Asteroids)
  • testing table – a table that lists each test with its expected result and actual result, so we can spot any differences. (13. Scoring)
  • TextObject – a special kind of GameFrame RoomObject that displays text on the screen. (13. Scoring)
  • Thonny – a program for writing, running and debugging Python code that is designed for beginners. (Using Thonny)
  • tick – one beat of the game clock, which in GameFrame happens every 1/30 of a second. (5. Keeping the Ship in the Room)
  • timer – a countdown that calls a chosen method when it reaches 0. (7. Asteroids)
  • top-down game – a game where we look down on the player from above as they move up, down, left and right. (Other Game Types)
  • traceback – the error report Python prints when a program crashes, showing the path it took to the error with the most recent step last. (1. Welcome Screen)
  • trigger – the event or condition that causes an action to happen. (2. GamePlay Room)
  • tuple – a group of values written in round brackets that works like a list but can't be changed. (14. Lives)

U

  • unfair punishment – when a game punishes the player for something they couldn't control, which damages their sense of control. (Game Design)
  • unpack – to store each value from a tuple or list in its own variable in one line, such as x, y = position. (Saving Data with a Database)

V

  • version control – a system that tracks changes to our files over time, so we can save versions of our work and go back to an earlier one if something breaks. (Setup)
  • virtual environment – a separate space for one Python project with its own Python setup and libraries, so changes in one project don't affect another. (Setup)
  • VS Code – short for Visual Studio Code, a professional IDE that works with many programming languages through extensions. (Setup)

W

  • what-if effect – when a player who fails thinks of things they could have done differently, which makes them want to try again. (Game Design)
  • wireframe – a simple plan of a screen that shows where things like buttons, images and text will go, focusing on layout rather than colours or details. (1. Welcome Screen)

X

  • x and y components – the horizontal and vertical parts that any movement on the screen can be split into. (8. Moving Asteroids)