C++ console game: Modifying a battle function that allows different enemy stats - c++

Question

I am creating a game using a 2D array grid, with the player controlling a character with enemies (with different stats/values) around the area. When the character is on the same grid as an enemy, the program initiates a battle function which contains large amounts of code that dictates how the battle works . However, since I want enemies to have different stats, I've been using structures in order to organize character/enemy stats.
For example:
struct Character { //character stats
int hp;
int atk;
int warpstk;
int heal;
int mana;
int money;
};
struct Enemy { //enemy stats
int mhp;
int matk;
int mwarpstk;
int mheal;
};
Character Player =
{
50, //Player.hp
10, //Player.atk
18, //Player.warpstk
12, //Player.heal
30, //Player.mana
50, //Player.money
};
Enemy Goblin =
{
40, //Goblin.mhp
10, //Goblin.matk
12, //Goblin.mwarpstk
8, //Goblin.heal
};
Enemy Dragon =
{
100, //Goblin.mhp
50, //Goblin.matk
70, //Goblin.mwarpstk
15, //Goblin.heal
};
//I want to modify the follow function so that it would change who the player is fighting depending on the grid placement.
void battleSequence(){
while (Player.hp > 0 && Goblin.hp > 0)
{
//randon battle code
}
int main()
{
if (player.x == goblin.x && player.y == goblin.y)
{
battleSequence();
if (Goblin.mhp < 1)
{
goblin.x = 25; //gave the goblin coordinates an out of bounds coordinate to leave loop
goblin.y = 25; //gave the goblin coordinates an out of bounds coordinate to leave loop
system("cls");
}
}
//Probably gonna do the same conditional for the dragon, but it entirely depends on the battle function
}
However, if I were to call the battle sequence function when my character is on the same grid as a goblin, how would I do it so it would be unnecessary to create a battle function of each and every enemy? How would I be able to avoid duplicate code lying around my program? Because so far, I have one function which uses only two variables for player stats: Player and Goblin, and I would hate to create another function for Player and Dragon, due to the length of the function (which is not shown here).
In other words, how would I be able to create ONE general battle sequence function that is accessable for every enemy, but I would only be fighting a "dragon" if I were on their grid, and only a "goblin" if I were on their grid?
(If you need more clarity, please do ask since it is pretty hard to comprehend my question. Ask if you need github repository of my current progress)

Answer 1

Could you simply make a base struct, called characterValues or something, which contains X and Y position, hp, att, Def, heal, and whatever else is common amongst all characters, or at least what's needed to perform a battle. Then the player struct contains an instance of this, as well as the enemy struct.
When you need to calculate the battles, you just need to compair player.charaterValues, with goblin.charaterValues or dragon.charaterValues. If two characters have the same X and Y value, then perform the battle with their health and attack data. Extra info can be stored seperte to this struct, like the players mana, or the enemy's loot data, etc.
If your writing this in c++, you should look upand read about inheritance if you haven't already, which can do some extra tricks along these lines. But with simple c, it can be done with nested structures.
Good luck with your game.

Answer 2

As already pointed out in the other answer, you must find out what all entities (players, goblins and dragons) have in common and create a "base struct", for example a struct CommonEntity, which is comprised of all common properties.
If you want the battle sequence to be strictly player vs. monster (or "enemy"), then it is not necessary for the player properties to be part of the struct CommonEntity. In that case, it would be sufficient for only all common monster properties to be in struct CommonEntity, and you could keep the player properties separate.
However, if monster vs. monster battles should also be possible, and if you want the same function to handle both types of battles, then it would probably be better to include all player properties in the struct CommonEntity, so that the battle function can treat players and monsters in exactly the same way and doesn't even have to know whether the combat participients are players or monsters.
The struct CommonEntity could look like this:
struct CommonEntity
{
//map coordinates
int x;
int y;
//combat stats
int hp;
int atk;
int warpstk;
int heal;
};
All of these properties are shared by both the player and all monsters. If mana can also used in combat, you might want to add it to the struct, and set it to zero for the monsters and nonzero for the players.
However, you probably want to be able to store additional information and the type of the additional information should depend on whether the entity is a player, goblin or dragon. For example, if it is a player, you want to be able to store the amount of money the player has. Therefore, you might want to use a union, like this:
struct AdditionalPlayerData
{
int money;
};
struct AdditionalGoblinData
{
//empty for now
};
struct AdditionalDragonData
{
//empty for now
};
struct Entity
{
//type of entity
enum class EntityType { player, goblin, dragon } type;
CommonEntity common;
union
{
AdditionalPlayerData player;
AdditionalGoblinData goblin;
AdditionalDragonData dragon;
};
};
Now, your struct is capable of storing both general information and additional information specific to the type of entity. You can always see which union field is valid by looking at the type member.
The function which evaluates the battle probably doesn't care about the additional information, it will only need to access the information contained in the common member. Therefore, you will no longer need a different function for handling different entity types, as the function probably won't even care about the type of entity. If it does care for some reason, it can still look up the type member and access the corresponding additional information in the union.
A more object-oriented approach to solving the problem would be the following:
You can use C++ inheritance by defining a common base class, class Entity, for all entities that exist in the game, for example class Player and class Enemy. Also, you can make class Enemy itself a base class for class Goblin, class Dragon, etc. You could then create an array (C-style or std::array) or std::vector of type class Entity * to reference all entities that exist in the game.
The functions which check for encounters and handle the actual battle then only have to deal with objects of type class Entity and do not care of what derived class these objects actually are. If these functions do need to determine the type of the entity, they can call a virtual function on the base class which will then automatically call the corresponding function in the derived class. In my example below, the functions handling the encounters and battles will call the virtual function GetEntityTypeName of class Entity to obtain the name of the entity type (i.e. "player", "goblin" or "dragon"), which they use to print a message about the encounter/battle to the screen.
#include <iostream>
#include <vector>
#include <memory>
#include <random>
class Entity
{
protected:
Entity() = delete;
Entity( int x, int y, int hp, int atk, int warpstk, int heal )
: x(x), y(y), hp(hp), atk(atk), warpstk(warpstk), heal(heal)
{}
public:
int GetX() { return x; }
int GetY() { return y; }
int GetHP() { return hp; }
int GetAttack() { return atk; }
int GetWarpStk() { return warpstk; }
int GetHeal() { return heal; }
void SetX( int newval ) { x = newval; }
void SetY( int newval ) { y = newval; }
void SetHP( int newval ) { hp = newval; }
//the following virtual function will call the derived class's
//function to retrieve the name of the entity type as a string
virtual const char* GetEntityTypeName() = 0;
protected:
//entity's coordinates
int x;
int y;
//entity's combat stats
int hp;
int atk;
int warpstk;
int heal;
};
//class Player inherits from class Entity
class Player : public Entity
{
public:
Player() = delete;
Player( int x, int y ) : Entity(x,y,50,10,18,12), mana(30), money(50) {}
//define additional functions
int GetMana() { return mana; }
int GetMoney() { return money; }
void SetMana( int newval ) { mana = newval; }
void SetMoney( int newval ) { money = newval; }
virtual const char* GetEntityTypeName() { return "player"; }
protected:
//define additional stats that are specific to player
int mana;
int money;
};
class Enemy : public Entity
{
protected:
Enemy() = delete;
Enemy( int x, int y, int hp, int atk, int warpstk, int heal )
: Entity(x, y, hp, atk, warpstk, heal)
{}
public:
//define additional functions here that are specific
//to all enemies, but not specific to certain enemy
//types (goblin, dragon, etc.)
//currently no additional functions
protected:
//define additional stats here that are specific to
//all enemies, but not specific to certain enemy types
//currently no additional stats
};
class Goblin : public Enemy
{
public:
Goblin() = delete;
Goblin( int x, int y ) : Enemy(x,y,40,10,12,8) {}
virtual const char* GetEntityTypeName() { return "goblin"; }
private:
//define additional stats here that are specific to goblins
//currently no additional stats
};
class Dragon : public Enemy
{
public:
Dragon() = delete;
Dragon( int x, int y ) : Enemy(x,y,100,50,70,15) {}
virtual const char* GetEntityTypeName() { return "dragon"; }
private:
//define additional stats here that are specific to dragons
//currently no additional stats
};
int MakeRandom( int min, int max, std::mt19937 &rng )
{
std::uniform_int_distribution<int> dis( min, max );
return dis( rng );
}
void PerformAttack( Entity &attacker, Entity &defender, std::mt19937 &rng )
{
int attack_strength = MakeRandom( 0, attacker.GetAttack(), rng );
std::cout << " " << attacker.GetEntityTypeName() << " hits " <<
defender.GetEntityTypeName() << " for " << attack_strength << " points\n";
defender.SetHP( defender.GetHP() - attack_strength );
}
void PerformBattleRound( Entity &e1, Entity &e2, std::mt19937 &rng )
{
Entity *first, *second;
//randomize which entity attacks first
if ( MakeRandom( 0, 1, rng ) == 0 )
{
first = &e1;
second = &e2;
}
else
{
first = &e2;
second = &e1;
}
//perform first attack
PerformAttack( *first, *second, rng );
if ( second->GetHP() <= 0 )
{
std::cout << " " << second->GetEntityTypeName() << " dies\n\n";
return;
}
else
{
std::cout << " " << second->GetEntityTypeName() << " has " <<
second->GetHP() << " HP remaining\n";
}
//perform second (counter) attack
PerformAttack( *second, *first, rng );
if ( first->GetHP() <= 0 )
{
std::cout << " " << first->GetEntityTypeName() << " dies\n\n";
return;
}
else
{
std::cout << " " << first->GetEntityTypeName() << " has " <<
first->GetHP() << " HP remaining\n";
}
std::cout << "\n";
}
void ProcessEncounters( std::vector<std::unique_ptr<Entity>> &entity_list, std::mt19937 &rng )
{
//this function does not only check encounters between player
//and enemies, but also enemies and enemies
int size = entity_list.size();
for ( int i = 0; i < size; i++ )
{
for ( int j = i + 1; j < size; j++ )
{
//check if both entities have the same coordinates
if (
entity_list[i]->GetX() == entity_list[j]->GetX() &&
entity_list[i]->GetY() == entity_list[j]->GetY()
)
{
//print information about encounter
std::cout <<
entity_list[i]->GetEntityTypeName() << " encounters " <<
entity_list[j]->GetEntityTypeName() << " at (" <<
entity_list[i]->GetX() << "," <<
entity_list[i]->GetY() << ")\n";
PerformBattleRound( *entity_list[i], *entity_list[j], rng );
}
}
}
}
int main()
{
//create a vector to contain all entities
std::vector<std::unique_ptr<Entity>> entity_list;
//seed the random number generator
std::random_device rd;
std::mt19937 rng( rd() );
//create player at coordinates (5,7)
entity_list.push_back( std::make_unique<Player>( 5, 7 ) );
//create goblin at coordinates (2,3)
entity_list.push_back( std::make_unique<Goblin>( 2, 3 ) );
//create goblin at coordinates (5,7)
entity_list.push_back( std::make_unique<Goblin>( 5, 7 ) );
//create goblin at coordinates (8,9)
entity_list.push_back( std::make_unique<Goblin>( 8, 9 ) );
//create dragon at coordinates (8,9)
entity_list.push_back( std::make_unique<Dragon>( 8, 9 ) );
ProcessEncounters( entity_list, rng );
}
}
The code above will print the following output:
player encounters goblin at (5,7)
goblin hits player for 1 points
player has 49 HP remaining
player hits goblin for 10 points
goblin has 30 HP remaining
goblin encounters dragon at (8,9)
goblin hits dragon for 2 points
dragon has 98 HP remaining
dragon hits goblin for 42 points
goblin dies
Due to the random number generator, the output will be different every time you run the program.
As you can see, I don't need an extra function for handling every type of entity, because the functions handling the encounter/battle do not even care about the type of entity they are dealing with.
Note that if you have 10,000 entities in the game, and if enemies can also encounter each other (not only the player), then it will take nearly 5 million(!) comparisons to compare every entity's coordinates with every other entity, as the time complexity is O(n2). Therefore, if you have that many entities, you might want to consider dividing the map into a grid of, for example, 100*100 tiles and keep a separate list of all entities that exist in every tile of that grid. That way, assuming 10,000 entities, you will only have to compare every entity with the coodinates of one other entity on average, instead of all other 10,000 entities. But as long as you have less than 100 entities in the game, it should not be a problem. Also, if enemies cannot encounter each other, then this will also not be a problem, as the time complexity will only be O(n) instead of O(n2).