Configuration Errors

Configuration errors occur when the development environment is not set up properly. These errors can prevent your code from compiling or running correctly. Here are some common configuration errors you may encounter:

For example, let’s say you’re developing a game and you receive a configuration error stating that the required graphics library is not found. This error indicates that the necessary configuration for your graphics library is missing. To resolve this, you need to ensure that the library is properly installed and its paths are correctly set in the project settings. An example article that covers this skill is Setting up the Visual Studio development environment.

Compile Errors

Compile errors occur when there are mistakes or inconsistencies in your code that prevent the compiler from translating them into machine-readable instructions. These errors are often caused by syntax errors, type mismatches, or missing declarations.

As an example, suppose you’re creating a game character class, and you forget to include a semicolon at the end of a class definition. This will result in a compile error, and the compiler will highlight the missing semicolon. To fix this error, simply add the semicolon at the appropriate location. These are the most common type of error and fortunately, the easiest to fix.

Here’s an example of a compile error in C++ code. Can you work it out for yourself?

#include <iostream> int main()
{
    int x = 10; int y = "20"; // Error: Type mismatch int sum = x + y;
    std::cout << "The sum is: " << sum << std::endl; return 0;
}

int y = "20"; // Error: Type mismatch

y

y

When you try to compile this code in Visual Studio, you will receive an error message indicating the type mismatch:

error: invalid conversion from 'const char*' to 'int'

y

int y = 20; // Fixed: Assigning an integer value

By correcting the type mismatch, the code will compile successfully, and you will get the desired output without any errors.

Link Errors

Link errors occur during the linking phase of compilation when the compiler tries to combine different object files and libraries to create the final executable. These errors are typically caused by missing function definitions or unresolved external symbols.

An example might help. Imagine you’re working on a game that uses a physics library. If you forget to include the necessary physics library files or provide the required function definitions, you will encounter a link error. To resolve this, ensure that you have included all the required libraries and properly link them with your project. To properly link all the files in an SFML game project, read this article: Building your first SFML game project.

Here’s another beginner-friendly example of a link error in C++ code:

#include <iostream>

int main()
{
    sayHello(); // Error: Undefined reference to 'sayHello'
    return 0;
}

void sayHello()
{
    std::cout << "Hello, World!" << std::endl;
}

sayHello()

main()

sayHello(); // Error: Undefined reference to 'sayHello'

sayHello()

main()

When you try to compile this code in Visual Studio, you will receive a link error message similar to:

error LNK2019: unresolved external symbol "void __cdecl sayHello(void)" (?sayHello@@YAXXZ) referenced in function _main

void sayHello()

main()

void sayHello()
{
    std::cout << "Hello, World!" << std::endl;
}

int main()
{
    sayHello(); // Function call return 0;
}

main()

sayHello()

Bugs

Bugs are issues that arise during the execution of your program. They can cause unexpected behavior, crashes, or incorrect results. Debugging is the process of identifying and fixing bugs.

Suppose you’re creating a game where the player’s character keeps falling through the floor. This unexpected behavior is a bug. To identify the cause, you can use the Visual Studio debugger. Set breakpoints, step through the code, and inspect variables to find the error. In this case, you might discover that the collision detection code is incorrect, and fixing it will resolve the bug.

Here’s an example of a bug in C++ code:

#include <iostream> int main()
{
    int x = 5; int y = 0;
    int division_result = x / y;
    std::cout << "The division result is: " << division_result << std::endl;
    return 0;
}

int division_result = x / y;

x

y

y

When you run this code in Visual Studio, you will encounter a runtime error:

Unhandled exception at 0x004115D2 in Example.exe: 0xC0000094: Integer division by zero.

y

int division_result;
if (y != 0)
{
    division_result = x / y;
}
else
{
    std::cout << "Error: Division by zero is not allowed." << std::endl; // Handle the error or exit the program gracefully
}

Summary

Handling errors while writing C++ code is an essential skill for developers. By understanding and addressing configuration errors, compile errors, link errors, and bugs, you can write more robust and reliable programs. Remember to pay attention to error messages, use the debugging tools available in the Visual Studio environment, and continually improve your coding skills to minimize errors and create high-quality games.

vector

To begin, let’s include the necessary header file for using vectors:

#include <vector>

int

string

std::vector<int> numbers; // An empty vector of integers
std::vector<std::string> names = {"Alice", "Bob", "Charlie"}; // A vector of strings with initial values

numbers

names

Now, let’s add elements to the vector using the

push_back

numbers.push_back(10); // Add 10 to the end of the numbers vector
names.push_back("Dave"); // Add "Dave" to the end of the names vector

push_back

numbers

names

To access elements in the vector, we can use the subscript operator

[]

at()

int firstNumber = numbers[0]; // Access the first element of the numbers vector
std::string secondName = names.at(1); // Access the second element of the names vector using the at() function (bounds-checked access)

numbers

names

at()

If we want to modify elements in the vector, we can directly assign new values:

numbers[0] = 20; // Modify the first element of the numbers vector to 20
names.at(2) = "Eve"; // Modify the third element of the names vector to "Eve"

numbers

names

at()

Looping through the vector is useful for iterating over its elements. Here are two examples of looping through the vector:

for (int i = 0; i < numbers.size(); i++)
{
    int num = numbers[i]; // Process num (e.g., print, perform calculations, etc.)
}

for (const std::string& name : names)
{
    // Process name (e.g., print, manipulate, etc.)
}

for

numbers.size() - 1

[]

for

names

name

Now, let’s work with pointers to

GameObject

#include <memory>

struct GameObject {
    // Define GameObject properties and methods
};

std::vector<std::shared_ptr<GameObject>> gameObjects; // Create a new GameObject instance and add it to the vector
std::shared_ptr<GameObject> newObject = std::make_shared<GameObject>();
gameObjects.push_back(newObject); // Loop through each GameObject in the vector

for (const std::shared_ptr<GameObject>& obj : gameObjects)
{
    // Access obj and perform game-related operations
}

<memory>

struct

GameObject

gameObjects

GameObject

To add a new

GameObject

std::make_shared<GameObject>()

gameObjects

push_back

Finally, we iterate over the

gameObjects

for

const std::shared_ptr<GameObject>&

To expand upon this idea look at the tutorial Programming a simple game engine in C++.

Setting up the game

To begin, create a new C++ project in your preferred development environment. Once you have created the project, create a new source file for your game. You can name it “main.cpp” or anything you like.

Defining game variables

Next, define the variables that will be used in the game. In this case, you will need variables to keep track of the player’s current location and the game’s state.

int location = 0;
bool gameRunning = true;

Creating the game loop

As we have learned before the game loop is the heart of your game. It will continuously run until the game is over. Inside the game loop, you will have to write code to handle the player’s input and update the game state accordingly.

while(gameRunning){
     // get player input
     // update game state
}

Implementing the game logic

The game logic defines how the player can interact with the game world. In this case, the player will need to navigate through different rooms in the dungeon to find a way to escape. You will need to define a list of possible actions the player can take in each room and what happens when they take that action.

Here’s an example code snippet to get you started:

while(gameRunning){
// display room description
// get player input
if (location == 0){ // player is in the cell
if (input == "look"){
     std::cout << "You are in a small, dank cell with a rusted iron door.\n";
}
else if (input == "open door"){
     std::cout << "The door is locked.\n";
}
else if (input == "use key"){
     std::cout << "You don't have a key.\n";
}
else if (input == "escape"){
     std::cout << "You can't escape from here without finding a way to open the door.\n";
}
else{
     std::cout << "I don't understand that command.\n";
}
}
// add more room descriptions and actions here
}

Adding game objects

To make the game more interesting, you can add objects that the player can interact with. For example, the player might find a key that can be used to unlock a door, or a weapon that can be used to fight enemies. You will need to define the objects and their properties, such as their name, description, and location.

struct Object{
std::string name;
std::string description;
int location;
};

Object key = {"key", "A small iron key.", 2};

You can then modify the game logic to handle the player interacting with objects:

int location = 0;

void movePlayer(std::string direction){
  if (direction == "north" && location == 0){
     location = 1;
     std::cout << "You have moved to the north.\n";
}
else if (direction == "south" && location == 1){
     location = 0;
     std::cout << "You have moved to the south.\n";
}
else{
     std::cout << "You cannot move in that direction.\n";
}
}

while(gameRunning){
     std::string input;
     std::cout << "You are in a " << rooms[location].description << ".\n";
     std::cout << "What would you like to do?\n";
     std::cin >> input;

if (input == "move"){
     std::string direction;
     std::cout << "Which direction would you like to move?\n";
     std::cin >> direction;
     movePlayer(direction);
}
else if (input == "quit"){
     gameRunning = false;
     std::cout << "Goodbye!\n";
}
else{
     std::cout << "Invalid input.\n";
}
}

This code defines a movePlayer function that takes a direction parameter and updates the location variable based on the player’s input. The while loop displays the room description and prompts the player for input. If the player inputs “move”, the code prompts the player for a direction and calls the movePlayer function. If the player inputs “quit”, the game ends.

To make the game more challenging, you can add multiple levels with increasing difficulty. Each level can have different puzzles and obstacles that the player must overcome to progress to the next level. For example, in the first level, the player might need to find a way to escape the dungeon, while in the second level, the player might have to navigate through a maze to reach the exit.

You can define each level as a separate function, and call them from the game loop based on the player’s progress, like this, perhaps:

void level1(){
// game logic for level 1
}

void level2(){
// game logic for level 2
}

while(gameRunning){
if (location == 0){ // player is in the cell
level1(); // call level 1 function
}
else if (location == 1){ // player is in level 2
level2(); // call level 2 function
}
// add more levels here
}

Adding game over conditions

Finally, to make the game more engaging, you can add game over conditions, such as running out of health, or failing to complete a puzzle within a certain time limit. You can use these conditions to end the game and display a game over screen to the player.

Time for a real game now. To get started we will need to setup a Visual Studio project that uses SFML.

To get started you would define your Texture class: A Texture class typically represents an image or texture that can be used for rendering. In the context of this tutorial, we assume that the Texture class has a constructor that takes a filename as an argument and loads the corresponding image file. You may also have other methods and properties in your Texture class depending on your specific needs.

Define your Texture class: A Texture class typically represents an image or texture that can be used for rendering. In the context of this tutorial, we assume that the Texture class has a constructor that takes a filename as an argument and loads the corresponding image file. You may also have other methods and properties in your Texture class depending on your specific needs.

class Texture {
public:
    // constructor
    Texture(std::string filename);
    // destructor
    ~Texture();
    // other methods and properties // ...
};

Include the necessary headers: To use maps in C++, you need to include the

<map>

<string>

#include <map>
#include <string>

Declare the map that will store instances of the Texture class: In C++, a map is a container that stores key-value pairs. In this case, we want to store instances of the Texture class with a string key that represents each texture. To do this, we declare a map with a string key and a pointer to a Texture object as the value.

std::map<std::string, Texture*> textures;

Add textures to the map: To add textures to the map, we first create instances of the Texture class using the constructor and pass in the corresponding filenames. We then add each Texture object to the map using a string key that represents the texture. In this example, we add two Texture objects to the map with the keys “texture1″ and “texture2″.

Texture* texture1 = new Texture("texture1.png");
Texture* texture2 = new Texture("texture2.png");
textures["texture1"] = texture1;
textures["texture2"] = texture2;

Access textures from the map: To access a Texture object from the map, we use the string key that was used to add the object to the map. In this example, we access the “texture1″ object and store it in a pointer called “texture”.

Texture* texture = textures["texture1"];

Delete Texture objects when you’re done with them: It’s important to properly manage memory when working with pointers to avoid memory leaks. In this case, we need to delete the Texture objects that were created with the “new” operator when we’re done with them.

delete texture1;
delete texture2;

This course is also the place to start if you want to progress to learn to code for many different development platforms. For example C++ is the language of Unreal Engine and CryEngine the two most advanced game engines available. This C++ course will be especially relevant if you are an aspiring indie developer who wants to make super-fast 2d games; perhaps you want to get your game on Steam? C++ is the place to start. To accompany this C++ course there will be practical projects that use the SFML C++ library which is probably the best way for someone just starting game development who wants to make 2d games for any of the desktop operating systems. These mini-projects will lead to full working game projects.

This C++ course will assume you know absolutely nothing about C++ or any other programming language. It will explain all jargon as we proceed through each tutorial.

At times in the course, we will take an optional break from theory to do an appropriate project. These projects are hands-on real coding and are much more fun than theory. All the projects will be as game related as possible, including some full working games. The tutorial list here will grow over the coming days and weeks.

Explaining code through comments

Sometimes I will add extra explanation or clarification within the code itself. To do this I will use C++ comments. Whenever you see a line of code with two forward slashes- like this // at the start, that line of code doesn’t do anything except tell you something about the code. In our C++ programs, we will use comments to remind us of what different blocks or lines of code achieve. Here is what a comment looks like.

// I am just a comment and don't really do anything

spaceShip.shoot(alien);

// The line of code above shoots an alien
// That was a useful comment wasn't it

Enough of all the introductions let’s get on with the tutorials.

The C++ game coding tutorials

The tutorials are designed to get you coding games as fast as possible. They are not fully comprehensive and some topics have been trimmed to the maximum. I am sure that the best way of learning to code C++ games; is to code C++ games. So the sooner we can start doing that the better. You will find that all of the practical C++ projects on this site come with loads of refresher information and of course lots of useful C++ comments using “//”. So don’t feel you need to master a topic before moving on. You can always refer back.

1 – Game Variables in C++

This tutorial introduces the fundamental C++ building blocks of our game, variables. The variables tutorial explains how we keep track of the state of our game when writing in C++. Variables can be everything from the players score to an entire level of our game. Let’s get started and learn about game data and variables in C++.

[widgets_on_pages id=”bcgp_cfgp_gpp”]

2 – Manipulating Game Variables in C++

This tutorial shows us the mathematical way in C++ that we can change our game’s data that is contained within our variables. After all, the player’s score does not remain static. Changing game variables in C++.

3 – Checking for conditions in C++

Now that we can use variables to represent all the vital data in our game we will see how we can test for important events called conditions within our game. How do we know when the player has lost their last life or achieved a new high-score? Find out about Checking for conditions in C++.

4 – Branching our C++ game code

Here we will use everything we learned about conditions and variables so far to make our game take a different course dependent upon an outcome. Learn about Branching our C++ game code.

5 – Looping our game code

In game coding, we will regularly want to execute parts of our code multiple times while making subtle or not-so-subtle variations to our C++ code on each pass. For example, each and every frame of our game is contained in just such a loop. This is how it works: Looping our game code.

6 – Organizing code with functions

Functions are the organizing blocks of our code. We can think of a function as a black box that does one very specific task and can be reused over and over. Learn how we organize our game code with C++ functions.

7 – Introducing OOP for C++ games

OOP is probably the most vital topic in modern game coding. How do we break down our planned game and the objects (like characters, spaceships, and levels) into its most appropriate constituent parts? Find out in this introduction to OOP in C++ game coding.

8 – Game data handling with C++ arrays

C++ arrays are what enable us to manage lots of objects in our game in an orderly manner. It is all well and good to have a well-designed object that can represent a zombie, an invader or a bullet; but what about when we need dozens, hundreds or even thousands of them? This brief tutorial solves the problem by learning about C++ arrays.
[widgets_on_pages id=”udemy_advert_cpp_2″][widgets_on_pages id=”udemy_code_details”]

9 – Using C++ references to make code faster

When we pass values to a function or return values from a function that is exactly what we are doing. Passing or returning a value. What happens is that a copy of the variable’s value is made, and sent into the function where it is used. Nothing happens to the actual variable itself. C++ references allow us to work around this. But why would we even want to? Using C++ references to make code faster.

10 – Controlling game memory with C++ pointers

Pointers have a bad reputation. They can appear complicated or convoluted. Add to this, the way pointers can be used in C++ code has evolved in recent years. I believe the best way to understand them is to use them in their original (old-fashioned) form. You can’t understand how an internal combustion engine works if you go straight to a supercar. So what is a pointer? Controlling game memory with pointers.

Be sure to complete all the related SFML game projects.

11 – Organizing game data with C++ Maps

Maps are a convenient, organized, fast and intuitive way to organize key-value-pairs. That, is, pairs of data which go together that map to one another. Read about Maps in C++.