Skip to content

Glossary

This glossary lists every technical term introduced on this site, in alphabetical order. Each term links to the page where it is first explained, and each page lists its new terms in a Terminology callout at the top.

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

A

  • abstraction – hiding complicated details behind simpler tools, so we can use something without knowing exactly how it works inside. (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 pass into a method or function 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 variable that belongs to an object and describes one of its features. (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 background.png and Background.png are not the same name. (1. Welcome Screen)
  • challenge – something the player has to overcome to win a game. (Game Design)
  • class diagram – a diagram that shows a class's 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 values (x, y) that gives a position on the screen, with x for the horizontal position and y for the vertical position. (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 – finding and fixing the mistakes in a program, for example by reading the error and checking the code. (Design Thinking Flowchart)
  • dictionary – a data structure that stores values with a key for each one. (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 key press or two objects colliding, that the program can respond to. (2. GamePlay Room)
  • event handler – the code, usually a method, that runs when a particular event happens. (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 waits for events to happen and then runs the code that responds to each one. (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 is either True or False and records the state of something, which our code checks to decide what to do. (10. Laser)
  • flowchart – a diagram that uses shapes and arrows to show the steps and decisions in an algorithm. (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 – short for Integrated Development Environment, a program that lets us write, edit, test and run code in one place. (Setup)
  • indentation – the spaces at the start of a line of code, which Python uses to show which block the line belongs to. (Common Errors)
  • index – the number that gives an item's position in a list, starting from 0. (2. GamePlay Room)
  • inheritance – when a subclass automatically receives all the attributes and methods of its parent class. (1. Welcome Screen)
  • instance – one object 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 runs our Python code, such as the Python in our virtual environment. (Using Thonny)
  • IPO table – short for Input Process Output table, a planning tool that sets out the output we want, the input that triggers it and the process that gets from one to the other. (3. Spaceship)

L

  • life – one of a limited number of chances a player has before the game ends. (14. Lives)
  • list – a data structure that stores items in order, which we can find by their index. (14. Lives)

M

  • maintainable – describes code that is organised so it is easy to read, change and add to later. (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 and describes an action the object can take. (Planning Your Game)
  • module – a Python file containing code, such as classes or functions, that can be imported into other files. (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 part of the game, such as the player's ship or the score, that combines data with the code that controls how it behaves. (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 a method inherited from the parent class with a new version in the subclass. (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 millions of tiny dots that make up a computer screen. (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 method or function 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 data structure that stores a group of values with no repeats. (14. Lives)
  • Shell – the panel in Thonny that shows errors and print output. (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 current condition of something in a program, such as whether the ship is allowed to shoot. (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 that is built from another class (its parent) and gets all of the parent's attributes and methods. (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 where a program's text output, such as messages from print and errors, is shown. (8. Moving Asteroids)
  • testing table – a table for recording tests, with columns for the test, the expected result, the actual result and the remedy. (13. Scoring)
  • TextObject – a special kind of GameFrame RoomObject that displays text on the screen. (13. Scoring)
  • Thonny – a Python editor designed for beginners that comes with Python built in. (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 data structure that groups values that belong together, such as the x and y of a coordinate. (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 split the values in a tuple into separate variables in one step. (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)