Types From Data Files

The Type Object pattern introduced in the previous lesson provides a flexible way to manage variations among game entities by externalizing their common properties into data. This avoids a proliferation of C++ classes and makes game updates and content creation more accessible.

In this final lesson in the chapter, we put this theory into practice, combining it with the SDL_RWops techniques covered previously. We will build the foundations of a system to load these type objects and their corresponding entities from external data, process that data, and use it to instantiate our C++ objects.

We'll use data serialized as text in this project. In the next chapter, we'll build a program using binary serialization, so we can establish experience in both approaches.

Starting Point

We'll build upon the code we created in the previous lesson. A complete version of that code is provided below:

Reading Type Objects

Let's start with our serialized type objects. We'll represent our types as comma-seperated values within a file called types.txt. An example collection of types might look something like this:

If you want to follow along, this file should be in the same directory as your compiled executable.

Using JSON

In the previous lesson, we were demonstrating the concept of serialized type objects using the friendlier JSON format:

1{
2  "Goblin": {
3    "name": "Goblin",
4    "level": 3,
5    "health": 100,
6    "damage": 15,
7    "art": "goblin.png",
8    "fightingStyle": "Swarm"
9  },
10  "Dragon": {
11    "name": "Dragon",
12    "level": 7,
13    "health": 500,
14    "damage": 45,
15    "art": "dragon.png",
16    "fightingStyle": "RangedSnipe"
17  }
18}

We could use that in our implementation instead of our more basic comma-seperated rows. And, in a more complex project, perhaps we should.

However, writing the code to deserialize JSON is significantly more difficult. If we wanted to use JSON, we'd generally enlist the help of a third-party library. We have a dedicated lesson on handling JSON using a popular library created by Niels Lohmann:

Using JSON in Modern C++

A practical guide to working with the JSON data format in C++ using the popular nlohmann::json library.

In our MonsterType struct, let's add a static function that will read our file, and return a std::vector of our MonsterType type objects. We'll create a Bestiary alias for this type:

1// MonsterType.h
2#pragma once
3#include <string>
4#include <vector>
5
6class Entity;
7class MonsterType;
8using Bestiary = std::vector<MonsterType>;
9
FightingStyle Enum|Show
10enum class FightingStyle { /*...*/ };
16
17struct MonsterType {
Previous Members (Unchanged)|Show
25
26  static Bestiary LoadMonsterTypes();
27};

Let's start our implementation by loading the entire types.txt file into a std::string, using techniques we covered earlier in the chapter. To keep things focused, we'll skip error checking in these examples:

1// MonsterType.cpp
2#include <SDL.h>
3#include <string>
4#include <vector>
5
6// ...
7
8Bestiary MonsterType::LoadMonsterTypes() {
9  char* Raw{static_cast<char*>(
10    SDL_LoadFile("types.txt", nullptr))};
11  std::string Data(Raw);
12  SDL_free(Raw);
13
14  Bestiary MonsterTypes;
15  // Populate the array (next)
16  return MonsterTypes;
17}

Deserializing Type Objects

Next, let's focus on populating the local MonsterTypes array within our function, so we can return all the types stored in our text file. Having loaded our serialized file, our Data string currently looks like this:

To deserialize this into a collection of type objects, we'll do three things:

Firstly, we'll identify all of the line breaks in our string, and then create a substring for each line. For this example file, that will leave us with two strings:

1. "Goblin,3,100,15,goblin.png,Swarm"
2. "Dragon,7,500,45,dragon.png,RangedSnipe"

Then, for each of these strings, we create a substring for each of the comma-seperated values. Each line will result in 6 substrings which, for our goblin example, will look like this:

1. "Goblin" (the name)
2. "3" (the level)
3. "100" (the health)
4. "15" (the damage)
5. "goblin.png" (the art file)
6. "Swarm" (the fighting style)

Finally, we need to create a MonsterType object using these values. This will involve converting the strings to the correct types that our MonsterType struct expects.

Splitting Strings into Tokens

Let's start by splitting a string into it's substrings (or "tokens") based on a delimiter. To split our string into its lines, our delimiter will be the new line character, \n. Then, to split each of those strings into the comma-seperated values, we'll split on the comma , delimiter.

This string-splitting capability will be useful in multiple locations, so we'll create an inline function for it in a new Utilities.h file. This function uses the same techniques we covered in our earlier lesson on parsing data using a std::string:

1// Utilities.h
2#pragma once
3#include <string>
4#include <vector>
5
6namespace Utilities {
7inline std::vector<std::string> SplitString(
8  const std::string& Str, char Delimiter
9) {
10  std::vector<std::string> Tokens;
11  size_t StartPos{0};
12  size_t FindPos;
13
14  while (
15    (
16      FindPos = Str.find(Delimiter, StartPos)
17    ) != std::string::npos
18  ) {
19    Tokens.push_back(
20      Str.substr(StartPos, FindPos - StartPos)
21    );
22    StartPos = FindPos + 1;
23  }
24
25  // Don't forget the last token
26  if (StartPos <= Str.length()) {
27    Tokens.push_back(Str.substr(StartPos));
28  }
29
30  return Tokens;
31}
32}

Parsing Data using std::string

Learn how to read, parse, and use config files in your game using std::string and SDL_RWops

Advanced: String Streams and std::getline()

Our SplitString() function can be implemented in a slightly simpler way using the standard library's string stream utility, in conjunction with std::getline(). Both are available within <sstream>:

1// Utilities.h
2#pragma once
3#include <sstream>
4#include <vector>
5#include <string>
6
7namespace Utilities{
8inline std::vector<std::string> SplitString(
9  const std::string& Str, char Delimiter
10) {
11  std::vector<std::string> Tokens;
12  std::string Token;
13  std::istringstream TokenStream(Str);
14
15  while (std::getline(
16    TokenStream, Token, Delimiter
17  )) {
18    Tokens.push_back(Token);
19  }
20  return Tokens;
21}
22}

We don't cover standard library streams here, but we have a full chapter on them in our advanced course, including a dedicated lesson on string streams specifically:

String Streams

A detailed guide to C++ String Streams using std::stringstream. Covers basic use cases, stream position seeking, and open modes.

Over in our MonsterType.cpp file, let's #include our new utility function and use it to first split our string into it's lines based on the line break \n delimiter, and then split each of these lines into its 6 values based on the comma , delimiter:

1// MonsterType.cpp
2#include "Utilities.h"
3// ...
4
5Bestiary MonsterType::LoadMonsterTypes() {
6  char* Raw{static_cast<char*>(
7    SDL_LoadFile("types.txt", nullptr))};
8  std::string Data(Raw);
9  SDL_free(Raw);
10
11  Bestiary MonsterTypes;
12  using namespace Utilities;
13  for (std::string& Line : SplitString(Data, '\n')) {
14    std::vector Fields{SplitString(Line, ',')};
15    // Create and push the type object
16    // ...
17  }
18
19  return MonsterTypes;
20}

Creating Type Objects

Within each iteration of our for loop, our Fields vector now has the 6 strings it needs to create the current type object - that is, each instance of MonsterType represented by the current line we're processing.

However, each of the fields is a std::string, so we need to convert it to the correct type expected by the MonsterType struct. In order, the fields correspond to:

1. MonsterType::Name - this is is a std::string, so we can use our deserialized value directly - no conversion needed
2. MonsterType::Level - this is an int, so we'll use std::stoi() to convert our string to an integer
3. MonsterType::Health - this is an int so we'll use std::stoi()
4. MonsterType::Damage - this is an int so we'll use std::stoi()
5. MonsterType::ArtFileDamage - this is a std::string so no conversion needed
6. MonsterType::Style - this is a value from our FightingStyle enum. We'll create a function to map the std::string to the corresponding FightingStyle.

We don't have any float values in this example but, if we did, we'd convert the strings to the floating point value using std::stof().

Let's start by adding our std::string to FightingStyle enum mapper. This function is only needed in the MonsterType.cpp file, so we'll add it there. We'll put it in an anonymous namespace to prevent polluting our global namespace:

1// MonsterType.cpp
2// ...
3
4namespace{
5FightingStyle StringToFightingStyle(
6  const std::string& StyleStr
7) {
8  if (StyleStr == "BruteForce") {
9    return FightingStyle::BruteForce;
10  }
11  if (StyleStr == "RangedSnipe") {
12    return FightingStyle::RangedSnipe;
13  }
14  return FightingStyle::Swarm; // Default
15}
16}
17
18// ...

Finally, in LoadMonsterTypes(), we'll populate our MonsterTypes array before returning it:

1// MonsterType.cpp
2// ...
3
4using Bestiary = std::vector<MonsterType>;
5Bestiary MonsterType::LoadMonsterTypes() {
6  char* Raw{static_cast<char*>(
7    SDL_LoadFile("types.txt", nullptr))};
8  std::string Data(Raw);
9  SDL_free(Raw);
10
11  Bestiary MonsterTypes;
12  for (std::string& Line : SplitString(Data, '\n')) {
13    std::vector Fields{SplitString(Line, ',')};
14    MonsterTypes.push_back({
15      // Name
16      Fields[0], 
17      // Level
18      std::stoi(Fields[1]), 
19      // Health
20      std::stoi(Fields[2]),
21      // Damage
22      std::stoi(Fields[3]), 
23      // Art File
24      Fields[4], 
25      // Fighting Style
26      StringToFightingStyle(Fields[5])
27    });
28  }
29
30  return MonsterTypes;
31}

Over in main, let's confirm everything is working:

1// main.cpp
2#include "MonsterType.h"
3#include "Entity.h"
4
5int main() {
6  Bestiary Types{MonsterType::LoadMonsterTypes()};
7  std::cout << "Types: ";
8  for (MonsterType& Type : Types) {
9    std::cout << Type.Name << ", ";
10  }
11}

1Types: Goblin, Dragon,

1// If Fields[5] is a string like "Swarm",
2// this will return FightingStyle::Swarm
3magic_enum::enum_cast<FightingStyle>(Fields[5])

Loading Dungeon Data

Now that our type objects are being loaded successfully, let's add some data to represent our dungeon. Each monster in our dungeon will be an Entity, whose Type is one of the type objects we deserialized.

Our serialized dungeon data might look something like below, where every line will represent an enemy, and the commas within each line delimit the type, x position, and y position of that enemy.

We'll call this file dungeon.txt and store it alongside our executable:

1Goblin,5,3
2Goblin,5,6
3Goblin,7,4
4Dragon,9,9

We can construct all the objects our dungeon requires, attaching the correct type object. For this example, we'll store them in a std::vector within a Dungeon instance.

Our Dungeon constructor will will be responsible for populating its Enemies array. To help with that, we'll provide a reference to our Bestiary - the array of type objects we deserialized earlier:

1// Dungeon.h
2#pragma once
3#include <vector>
4#include "Entity.h"
5#include "MonsterType.h"
6
7struct Dungeon {
8  Dungeon(const Bestiary& Types) {
9    // Populate Enemies (next)
10  }
11
12  std::vector<Entity> Enemies;
13};

Deserializing Dungeons

To populate our Enemies from the serialized data, let's start by following the same pattern as before. We'll load our dungeon.txt file into a std::string. We'll then use our SplitString() utility to split that string into a vector of lines, and then each line into a vector of values:

1// Dungeon.h
2#pragma once
3#include <string>
4#include <vector>
5#include <SDL.h>
6#include "Entity.h"
7#include "MonsterType.h"
8#include "Utilities.h"
9
10struct Dungeon {
11  Dungeon(const Bestiary& Types) {
12    char* Raw{static_cast<char*>(
13      SDL_LoadFile("dungeon.txt", nullptr))};
14    std::string Data(Raw);
15    SDL_free(Raw);
16
17    using namespace Utilities;
18    for (std::string& Line : SplitString(Data, '\n')) {
19      std::vector Fields{SplitString(Line, ',')};
20      // Construct an entity and add to Enemies array
21    }
22  }
23
24  std::vector<Entity> Enemies;
25};

This time, each entry in our Fields array has only three values but, as before, they're all std::strings. To construct an Entity, we need the following conversions:

1. Entity::Type is a MonsterType pointer. We'll need to convert the std::string to the appropriate pointer within our type object collection, which is the Bestiary provided to our constructor.
2. Entity::X_Pos is an int, so we'll convert the second std::string in Fields to an int using std::stoi().
3. Entity::Y_Pos is also an int, so we'll use std::stoi() on the third value in Fields too.

Let's start by creating a static function that will convert the type string to the corresponding MonsterType pointer from the bestiary. The MonsterType struct seems like the natural place for such a function:

1// MonsterType.h
2// ...
3
4struct MonsterType {
5  // ...
6  
7  static const MonsterType* FindType(
8    const Bestiary& Types,
9    const std::string& DesiredType
10  ) {
11    for (const MonsterType& Type : Types) {
12      if (Type.Name == DesiredType) return &Type;
13    }
14    return nullptr;
15  }
16};

Back in our Dungeon constructor, let's use this new FindType() function, alongside std::stoi() , to populate our collection of enemies:

1// Dungeon.h
2#pragma once
3#include <string>
4#include <vector>
5#include <SDL.h>
6#include "Entity.h"
7#include "MonsterType.h"
8#include "Utilities.h"
9
10struct Dungeon {
11  Dungeon(const Bestiary& Types) {
12    char* Raw{static_cast<char*>(
13      SDL_LoadFile("dungeon.txt", nullptr))};
14    std::string Data(Raw);
15    SDL_free(Raw);
16
17    using namespace Utilities;
18    for (std::string& Line : SplitString(Data, '\n')) {
19      std::vector Fields{SplitString(Line, ',')};
20      Enemies.emplace_back(Entity{
21        // Type Object
22        MonsterType::FindType(Types, Fields[0]),
23        std::stoi(Fields[1]), // X Position
24        std::stoi(Fields[2]), // Y Position
25      });
26    }
27  }
28
29  std::vector<Entity> Enemies;
30};

Finally, let's create a Dungeon and confirm everything is working:

1// main.cpp
2#include "MonsterType.h"
3#include "Entity.h"
4#include "Dungeon.h"
5
6int main(int argc, char** argv) {
7  Bestiary TypeObjects{
8    MonsterType::LoadMonsterTypes()
9  };
10  std::cout << "Types: ";
11  for (const MonsterType& Type : TypeObjects) {
12    std::cout << Type.Name << ", ";
13  }
14
15  Dungeon DragonsLair{TypeObjects};
16  std::cout << "\nEnemies: \n";
17  for (const Entity& E : DragonsLair.Enemies) {
18    std::cout << "  " << E.Type->Name
19      << " (" << E.X_Pos << ", "
20      << E.Y_Pos << ")\n";
21  }
22
23  return 0;
24}

1Types: Goblin, Dragon,
2Enemies:
3  Goblin (5, 3)
4  Goblin (5, 6)
5  Goblin (7, 4)
6  Dragon (9, 9)

Complete Code

A complete version of the program we created over the last two lessons is provided below:

Summary

In this lesson, we put the Type Object pattern into action by reading MonsterType definitions and Entity configurations from external files. We used SDL_LoadFile() for file input and developed string parsing logic to convert text data into C++ MonsterType and Entity objects, creating a data-driven foundation for game content.

Key Takeaways:

• External files (like types.txt, dungeon.txt) can define game object characteristics.
• SDL's file utilities like SDL_LoadFile() help read data for parsing.
• Parsing often involves splitting file content into smaller parts, often recursively (eg, data into lines, and then lines into individual fields.
• String tokens need conversion to specific data types like int using std::stoi(), or custom enums using helper functions or external libraries.
• Loaded type objects can be stored (e.g., in a Bestiary) and used to instantiate game entities.
• This method externalizes game data, making it easier to manage and modify without requiring C++ knowledge.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course