What would be the best way to create multiple entities like Pokemon?

[AdventWolf]

I'm messing with classes and I'm wondering what would be a good way to create a list of monsters like Pokemon.
I could have a Pokemon class and make them from that like this:

class Pokemon {
	string name;
	string type
	int HP;
	int str;
	int def;
	string skills[20];
public:
        Pokemon(string nam,string typ,int hp,int str,int def);
};

And I could create a Pokemon like this:

Pokemon pkm0 = Pokemon("Pikachu","Electric",20,20,20)

Since pokemon have a different number of skills, I can't have an exact number constant to the class, so how would I go about labeling the skills?
Would I have to go pkm0.skills[0] = "x", pkmn[0].skills[1] = "xx".

Or maybe I could have the base Pokemon class with subclasses for each pokemon with the exact numbers. But with that, it would be much more lengthy and would probably take up a lot of unnecessary space.

[Thumper]

if you're goal is to make a small game i would make a subclass for every pokemon. Unless you're goal is to model all pokemon, in which case i'd make a way to store sort of a.. database of pokemon attributes, and load them into your class.

If you were to do it like that, yes you'd need to have the skill entered individually, which is why i mentioned a 'database'. Your program would load the database file, and read every entry, which would feed into your data. Afterwards, you could use a list to store multiple instances of Pokemon.

std::list<Pokemon*> pokemonList;

Then add onto that list

pokemonList.push_back(new Pokemon("Pikachu", "Electric", 20, 20, 20));

then loop through the pokemon to add the skills

std::list<Pokemon*>::iterator i = pokemonList.begin()
while(i != pokemonList.end())
{
        //do whatever code to pull data from your database

        (*i)->AddSkill(/*skill name you pulled from database*/) //or something of that sort.
        ++i;
}

To delete a pokemon you'd

//inside a loop
delete *i;
i = pokemonList.erase(i);

[kfmfe04]

Thumper is right - unless you are writing a small app with a limited number of Pokemon (I suspect it would be hard to stop creating them once you start), database-driven code would be your best bet.

If you stuff your Pokemon data in Mysql, for example, you will be able to query on various Pokemon types or instantiate your objects based on a SQL statement. If you prefer more structure, Postgresql will allow you to create a OODB where you could define your Objects in the database itself. On the other end of the scale, you could always stuff this data in comma-delimited or pipe-delimited text file.

It all depends on your requirements, but putting all the data in one place (not in your code) will make for much easier maintenance.

[AdventWolf]

Thanks for the replies, I see what you're saying and I have a database of skills set up, but I'm confused where

(*i)->AddSkill("Tackle"); // Added "Tackle" to test it 

shows in the code. I'm unfamiliar with the setup of lists, so I'm unsure of what kind of code I would need to include to assign a skill to a Pokemon.

I tried something simple to try to figure it out

AddSkill(string str)
{
	skills[0] = str;
}

And I tried to output skills[0] but I didn't get anything. I was able to output the name, so I'm not sure what the problem is :(.

[kfmfe04]

Try this instead:

i->AddSkill("Tackle"); // Added "Tackle" to test it 

[Thumper]

(*i)->AddSkill("Tackle"); assumes you're using an iterator to access it, and your list is made of Pokemon pointers. When you store objects in lists, you use an 'iterator' to move through it.


I wrote a quick example

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <limits>

using namespace std;

class Pokemon
{
public:
	void AddSkill(std::string name);
	void CoutSkills();

	std::vector<std::string> skills;
};

void Pokemon::AddSkill(std::string name)
{
	skills.push_back(name);
}

void Pokemon::CoutSkills()
{
	for(int i = 0; i < skills.size(); ++i)
	{
		cout << skills[i] << endl;
	}
}

int main()
{
	std::list<Pokemon*> pokemon;
	pokemon.push_back(new Pokemon);
	pokemon.push_back(new Pokemon);

	std::list<Pokemon*>::iterator itr = pokemon.begin();
	while(itr != pokemon.end())
	{
		(*itr)->AddSkill("Tackle");
		(*itr)->CoutSkills();
		++itr;
	}

	itr = pokemon.begin();
	while(itr != pokemon.end())
	{
		delete *itr;
		itr = pokemon.erase(itr);
	}

	cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

	return 0;
}

[AdventWolf]

It was my bad, I had the AddSkill part commented out on accident haha.

Anyways I have this set up now:

void PokemonManager::SkillAssigner()
{
	std::list<Pokemon*>::iterator i = pokemonList.begin();
	int x = 0;
	while(i != pokemonList.end())
	{
		string atk[3] = { "Tackle","Growl","Thundershock" };
		while( x < 3 )
		{
			(*i)->AddSkill(atk[x],x);
			++x;
		}
        ++i;
	}
}

Where AddSkill is this:

void Pokemon::AddSkill(string str, int x)
{
	skills[x] = str;
}

Now that I pretty much see how it works, I'll try to expand on it and implement the database.
Do you guys have any pointers on improving the structure of the code?

[ne555]

std::list<Pokemon*> pokemonList;
pokemonList.push_back(new Pokemon("Pikachu", "Electric", 20, 20, 20));

If you aren't using polymorphism, why did you made a list of pointers instead of a list of objects?
Erase a member will be easier, because you don't have to worry about delete.
And instead of (*it)->memfunc(); you will have it->memfunc();

[kfmfe04]

Well, I do not know too much about Pokemon, but I suspect there are penalties and bonuses based on attacks vs creature-type. For example (I am guessing here), Water vs Fire +10%, etc... So you may want to create some kind of method which would return a double (eg 1.1) based on AttackType vs DefenseType. Maybe call it:

double getBonusModifier( const string& attackType, const string& defenseType) const;

Of course, if you know all the attackTypes and defenseTypes, an enumeration would be even more type-safe. You can make this table data-driven by storing it in a 2D matrix of attackType vs defensType.

BTW, ne555 has a good point - if you do not intend to use polymorphism, it is better to store the entire object in the list. Or if you want to access them by name:

std::map<string,Pokemon> pokemonMap;

[AdventWolf]

Would having a list of pointers be more efficient?

I made a text based pokemon game a while back, but the coding was just awful lol. I'm trying to rewrite it clean with classes and to be more efficient, and add graphics as well.

Also to find a pokemon object I was wondering maybe I could have a list of the objects to store them, then use a map to have the <name, pointer to a pokemon object> so I could easily locate it by name.

[Thumper]

ne555 wrote:

If you aren't using polymorphism, why did you made a list of pointers instead of a list of objects

Works either way. He might later add some polymorphic(?) function.

AdventWolf wrote:

then use a map to have the <name, pointer to a pokemon object>

Possible, you could also use the name you defined in your pokemon class. Make a getname function or something, and iterate through the list and find the pokemon with the name you're looking for. That's how i'd do it. Mostly because i don't have experience with maps, and i'm not sure what their purpose is :P

[AdventWolf]

Alright so I added a map:

std::map<std::string, Pokemon> p_map;

Then the function to retrieve the Pokemon

Pokemon& GetPokemon(string name);

Pokemon& PokemonManager::GetPokemon(std::string name)
{
	return p_map[name];
}

And to test it out I initiated one of the map elements like this:
pokemonList.push_back(p_map["Pikachu"] = Pokemon("Pikachu","Electric",20,20,20));

std::cout << "Name: " << GetPokemon("Pikachu").name;

And it outputted the name from the Pokemon class.
So I guess I got it to do what I needed it to do, but is there a more efficient way to do this? lol