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: ```c++ #include "MonsterType.h" #include "Entity.h" int main(int argc, char** argv) { using enum FightingStyle; MonsterType GoblinType{ "Goblin", 3, 100, 15, "goblin.png", Swarm }; MonsterType DragonType{ "Dragon", 7, 500, 45, "dragon.png", RangedSnipe }; Entity Enemy{ GoblinType.CreateInstance(5, 10)}; Enemy.Render(); Enemy.ChangeType(&DragonType); Enemy.Render(); return 0; } ``` ```c++ #pragma once #include #include "MonsterType.h" class Entity { public: Entity(const MonsterType* Type, int x, int y) : Type{Type}, X_Pos{x}, Y_Pos{y}, CurrentHealth{Type->MaxHealth} {} const MonsterType* Type; void ChangeType(const MonsterType* NewType) { if (!NewType) return; // Or handle error std::cout << X_Pos << "," << Y_Pos << ": " << Type->Name << " is transforming into a " << NewType->Name << "!\n"; Type = NewType; CurrentHealth = Type->MaxHealth; } void Render() { if (!Type) { // Handle error return; } std::cout << X_Pos << "," << Y_Pos << ": Rendering " << Type->Name << " using art file: " << Type->ArtFile << "\n"; } int X_Pos; int Y_Pos; int CurrentHealth; }; ``` ```c++ #pragma once #include class Entity; enum class FightingStyle { Swarm, BruteForce, RangedSnipe }; struct MonsterType { std::string Name; int Level; int MaxHealth; int Damage; std::string ArtFile; FightingStyle Style; Entity CreateInstance(int x, int y) const; }; ``` ```c++ #include "MonsterType.h" #include "Entity.h" Entity MonsterType::CreateInstance( int x, int y ) const { return Entity{this, x, y}; } ``` ## 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: ```plain text Goblin,3,100,15,goblin.png,Swarm Dragon,7,500,45,dragon.png,RangedSnipe ``` 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: ```json { "Goblin": { "name": "Goblin", "level": 3, "health": 100, "damage": 15, "art": "goblin.png", "fightingStyle": "Swarm" }, "Dragon": { "name": "Dragon", "level": 7, "health": 500, "damage": 45, "art": "dragon.png", "fightingStyle": "RangedSnipe" } } ``` 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:

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: ```c++ // MonsterType.h #pragma once #include #include // class Entity; class MonsterType;// using Bestiary = std::vector;// // //enum class FightingStyle { /*...*/ }; enum class FightingStyle { Swarm, BruteForce, RangedSnipe }; // struct MonsterType { // std::string Name; int Level; int MaxHealth; int Damage; std::string ArtFile; FightingStyle Style; Entity CreateInstance(int x, int y) const; // static Bestiary LoadMonsterTypes();// }; ``` 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: ```c++ // MonsterType.cpp #include // #include // #include // // ... Bestiary MonsterType::LoadMonsterTypes() { char* Raw{static_cast( SDL_LoadFile("types.txt", nullptr))}; std::string Data(Raw); SDL_free(Raw); Bestiary MonsterTypes; // Populate the array (next) return MonsterTypes; } ``` ## 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: ```plain text Goblin,3,100,15,goblin.png,Swarm Dragon,7,500,45,dragon.png,RangedSnipe ``` 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`: ```c++ // Utilities.h #pragma once #include #include namespace Utilities { inline std::vector SplitString( const std::string& Str, char Delimiter ) { std::vector Tokens; size_t StartPos{0}; size_t FindPos; while ( ( FindPos = Str.find(Delimiter, StartPos) ) != std::string::npos ) { Tokens.push_back( Str.substr(StartPos, FindPos - StartPos) ); StartPos = FindPos + 1; } // Don't forget the last token if (StartPos <= Str.length()) { Tokens.push_back(Str.substr(StartPos)); } return Tokens; } } ``` ### 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 ``: ```c++ // Utilities.h #pragma once #include // #include #include namespace Utilities{ inline std::vector SplitString( const std::string& Str, char Delimiter ) { std::vector Tokens; std::string Token; std::istringstream TokenStream(Str);// while (std::getline( TokenStream, Token, Delimiter )) { Tokens.push_back(Token); } return Tokens; } } ``` 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: 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: ```c++ // MonsterType.cpp #include "Utilities.h"// // ... Bestiary MonsterType::LoadMonsterTypes() { char* Raw{static_cast( SDL_LoadFile("types.txt", nullptr))}; std::string Data(Raw); SDL_free(Raw); Bestiary MonsterTypes; using namespace Utilities; for (std::string& Line : SplitString(Data, '\n')) {// std::vector Fields{SplitString(Line, ',')};// // Create and push the type object// // ...// }// return MonsterTypes; } ``` ### 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: ```c++ // MonsterType.cpp // ... namespace{ FightingStyle StringToFightingStyle( const std::string& StyleStr ) { if (StyleStr == "BruteForce") { return FightingStyle::BruteForce; } if (StyleStr == "RangedSnipe") { return FightingStyle::RangedSnipe; } return FightingStyle::Swarm; // Default } } // ... ``` Finally, in `LoadMonsterTypes()`, we'll populate our `MonsterTypes` array before returning it: ```c++ // MonsterType.cpp // ... using Bestiary = std::vector; Bestiary MonsterType::LoadMonsterTypes() { char* Raw{static_cast( SDL_LoadFile("types.txt", nullptr))}; std::string Data(Raw); SDL_free(Raw); Bestiary MonsterTypes; for (std::string& Line : SplitString(Data, '\n')) { std::vector Fields{SplitString(Line, ',')}; MonsterTypes.push_back({// // Name Fields[0], // // Level std::stoi(Fields[1]), // // Health std::stoi(Fields[2]),// // Damage std::stoi(Fields[3]), // // Art File Fields[4], // // Fighting Style StringToFightingStyle(Fields[5])// });// } return MonsterTypes; } ``` Over in `main`, let's confirm everything is working: ```c++ // main.cpp #include "MonsterType.h" #include "Entity.h" int main() { Bestiary Types{MonsterType::LoadMonsterTypes()}; std::cout << "Types: "; for (MonsterType& Type : Types) { std::cout << Type.Name << ", "; } } ``` ```c++ // Types: Goblin, Dragon, ``` ### Enum Casting In this section, we added a function for mapping strings to enum values. That function required us to check every possible value in the enum. This is fine for simple cases but, in more complex projects, we'd want to build a better system, or use a library to help us. A popular choice is [Magic Enum](https://github.com/Neargye/magic_enum) which, among other things, allows strings to be converted to the enum value with the same name. That would allow us to replace our `StringToFightingStyle()` function, and any similar function we might have needed in the future, with code that looks like this: ```c++ // If Fields[5] is a string like "Swarm", // this will return FightingStyle::Swarm magic_enum::enum_cast(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: ```c++ Goblin,5,3 Goblin,5,6 Goblin,7,4 Dragon,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: ```c++ // Dungeon.h #pragma once #include #include "Entity.h" #include "MonsterType.h" struct Dungeon { Dungeon(const Bestiary& Types) { // Populate Enemies (next) } std::vector Enemies; }; ``` ## 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: ```c++ // Dungeon.h #pragma once #include // #include #include // #include "Entity.h" #include "MonsterType.h" #include "Utilities.h"// struct Dungeon { Dungeon(const Bestiary& Types) { char* Raw{static_cast( SDL_LoadFile("dungeon.txt", nullptr))}; std::string Data(Raw); SDL_free(Raw); using namespace Utilities; for (std::string& Line : SplitString(Data, '\n')) { std::vector Fields{SplitString(Line, ',')}; // Construct an entity and add to Enemies array } } std::vector Enemies; }; ``` This time, each entry in our `Fields` array has only three values but, as before, they're all `std::string`s. 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: ```c++ // MonsterType.h // ... struct MonsterType { // ... static const MonsterType* FindType( const Bestiary& Types, const std::string& DesiredType ) { for (const MonsterType& Type : Types) { if (Type.Name == DesiredType) return &Type; } return nullptr; } }; ``` Back in our `Dungeon` constructor, let's use this new `FindType()` function, alongside `std::stoi()` , to populate our collection of enemies: ```c++ // Dungeon.h #pragma once #include #include #include #include "Entity.h" #include "MonsterType.h" #include "Utilities.h" struct Dungeon { Dungeon(const Bestiary& Types) { char* Raw{static_cast( SDL_LoadFile("dungeon.txt", nullptr))}; std::string Data(Raw); SDL_free(Raw); using namespace Utilities; for (std::string& Line : SplitString(Data, '\n')) { std::vector Fields{SplitString(Line, ',')}; Enemies.emplace_back(Entity{// // Type Object// MonsterType::FindType(Types, Fields[0]),// std::stoi(Fields[1]), // X Position// std::stoi(Fields[2]), // Y Position// });// } } std::vector Enemies; }; ``` Finally, let's create a `Dungeon` and confirm everything is working: ```c++ // main.cpp #include "MonsterType.h" #include "Entity.h" #include "Dungeon.h" int main(int argc, char** argv) { Bestiary TypeObjects{ MonsterType::LoadMonsterTypes() }; std::cout << "Types: "; for (const MonsterType& Type : TypeObjects) { std::cout << Type.Name << ", "; } Dungeon DragonsLair{TypeObjects};// std::cout << "\nEnemies: \n";// for (const Entity& E : DragonsLair.Enemies) {// std::cout << " " << E.Type->Name// << " (" << E.X_Pos << ", "// << E.Y_Pos << ")\n";// }// return 0; } ``` ```c++ // Types: Goblin, Dragon, Enemies: Goblin (5, 3) Goblin (5, 6) Goblin (7, 4) Dragon (9, 9) ``` ## Complete Code A complete version of the program we created over the last two lessons is provided below: ```c++ #include "MonsterType.h" #include "Entity.h" #include "Dungeon.h" int main(int argc, char** argv) { Bestiary TypeObjects{ MonsterType::LoadMonsterTypes() }; std::cout << "Types: "; for (const MonsterType& Type : TypeObjects) { std::cout << Type.Name << ", "; } Dungeon DragonsLair{TypeObjects}; std::cout << "\nEnemies: \n"; for (const Entity& E : DragonsLair.Enemies) { std::cout << " " << E.Type->Name << " (" << E.X_Pos << ", " << E.Y_Pos << ")\n"; } return 0; } ``` ```c++ // Entity.h #pragma once #include #include "MonsterType.h" class Entity { public: Entity(const MonsterType* Type, int x, int y) : Type{Type}, X_Pos{x}, Y_Pos{y}, CurrentHealth{Type->MaxHealth} {} const MonsterType* Type; void ChangeType(const MonsterType* NewType) { if (!NewType) return; // Or handle error std::cout << X_Pos << "," << Y_Pos << ": " << Type->Name << " is transforming into a " << NewType->Name << "!\n"; Type = NewType; CurrentHealth = Type->MaxHealth; } void Render() { if (!Type) { // Handle error return; } std::cout << X_Pos << "," << Y_Pos << ": Rendering " << Type->Name << " using art file: " << Type->ArtFile << "\n"; } int X_Pos; int Y_Pos; int CurrentHealth; }; ``` ```c++ #pragma once #include #include class Entity; class MonsterType; using Bestiary = std::vector; enum class FightingStyle { Swarm, BruteForce, RangedSnipe }; struct MonsterType { std::string Name; int Level; int MaxHealth; int Damage; std::string ArtFile; FightingStyle Style; Entity CreateInstance(int x, int y) const; static Bestiary LoadMonsterTypes(); static const MonsterType* FindType( const Bestiary& Types, const std::string& DesiredType ) { for (const MonsterType& Type : Types) { if (Type.Name == DesiredType) return &Type; } return nullptr; } }; ``` ```c++ #include #include #include #include "Utilities.h" #include "MonsterType.h" #include "Entity.h" Entity MonsterType::CreateInstance( int x, int y ) const { return Entity{this, x, y}; } namespace{ FightingStyle StringToFightingStyle( const std::string& StyleStr ) { if (StyleStr == "BruteForce") { return FightingStyle::BruteForce; } if (StyleStr == "RangedSnipe") { return FightingStyle::RangedSnipe; } return FightingStyle::Swarm; // Default } } Bestiary MonsterType::LoadMonsterTypes() { char* Raw{static_cast( SDL_LoadFile("types.txt", nullptr))}; std::string Data(Raw); SDL_free(Raw); Bestiary MonsterTypes; using namespace Utilities; for (std::string& Line : SplitString(Data, '\n')) { std::vector Fields{SplitString(Line, ',')}; MonsterTypes.push_back({ Fields[0], std::stoi(Fields[1]), std::stoi(Fields[2]), std::stoi(Fields[3]), Fields[4], StringToFightingStyle(Fields[5]) }); } return MonsterTypes; } ``` ```c++ #pragma once #include #include #include #include "Entity.h" #include "MonsterType.h" #include "Utilities.h" struct Dungeon { Dungeon(const Bestiary& Types) { char* Raw{static_cast( SDL_LoadFile("dungeon.txt", nullptr))}; std::string Data(Raw); SDL_free(Raw); using namespace Utilities; for (std::string& Line : SplitString(Data, '\n')) { std::vector Fields{SplitString(Line, ',')}; Enemies.emplace_back(Entity{ // Type Object MonsterType::FindType(Types, Fields[0]), std::stoi(Fields[1]), // X Position std::stoi(Fields[2]), // Y Position }); } } std::vector Enemies; }; ``` ```c++ #pragma once #include #include namespace Utilities { inline std::vector SplitString( const std::string& Str, char Delimiter ) { std::vector Tokens; size_t StartPos{0}; size_t FindPos; while ( ( FindPos = Str.find(Delimiter, StartPos) ) != std::string::npos ) { Tokens.push_back( Str.substr(StartPos, FindPos - StartPos) ); StartPos = FindPos + 1; } // Don't forget the last token if (StartPos <= Str.length()) { Tokens.push_back(Str.substr(StartPos)); } return Tokens; } } ``` ```c++ Goblin,3,100,15,goblin.png,Swarm Dragon,7,500,45,dragon.png,RangedSnipe ``` ```c++ Goblin,5,3 Goblin,5,6 Goblin,7,4 Dragon,9,9 ``` ## 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.

Types From Data Files

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation