Handling 'units' in an RTS game - c++ - c++

Question

I'm currently in the process of making a simple RTS style game in c++.
What i'm wondering is how to handle the creation of new units in the game (ie. making marines from the barrack). How would i store these units?
I was thinking of having a class 'unit' which would then be inherited by specific unit types (ie. marines, firebats, etc) but if i create an array for these (ie. Marines myMarines[20]) that will create a hard cap on these units.
How do i create such an array that can be expanded at will?
Thank you!

Answer 1

The standard library provides them std::vector template for dynamically resizable arrays. A std::vector<Marine> would be the most straightforward alternative to Marines myMarines[20].
However, you probably don't want a separate list for each unit type. It is highly likely that you will want to store all units in the same list, regardless of their type. std::vector<Unit> would sound like the obvious solution but it is not. The problem is that std::vector stores the objects by value. The following would not work right:
std::vector<Unit> v;
v.push_back(Marine("John Doe"));
The problem is that the Marine object will be copied into a Unit object, which is what the vector stores. This kind of copy results in a what is known as slicing: all the Marine specific members will be lost, and only those that exist in Unit will be stored.
One solution to this problem is to store pointers in the vector because copying pointers does not change the objects they point to. But that brings other problems. To store pointers, this means you'll need to allocate the objects dynamically. And that means that now you are responsible for destroying those objects manually. That's a tiresome and error-prone task.
The solution is to store in the vector objects that destroy the dynamically allocated objects automatically, instead of pointers. These objects are known as smart pointers. The simplest one that exists in the standard library is std::unique_ptr.
std::vector<std::unique_ptr<Unit>> v;
v.emplace_back(new Marine("John Doe"));
This is a C++11 feature. If your compiler doesn't support it you can find alternatives in the Boost libraries. Boost even includes a container that acts pretty much like a std::vector of std::unique_ptrs: boost::ptr_vector. That would be another alternative.

Answer 2

You will probably benefit from using an std::vector here. This will allow you to add and remove items at will, and handles dynamic memory allocation internally (without concerning you over the nitty-gritty details!).
Say you want to store a list of marines (denoted by an imaginary class CMarine in the following example):
std::vector<CMarine> marinesList;
Now to add a marine simply do this:
marinesList.push_back( CMarine( <whatever-its-constructor-takes> ) );
To access this marine you can do something like this:
CMarine& marine = marinesList.at( 0 );
marine.someVar = 33;
marine.doMethod();
(I use a reference since CMarine could very well be too bulky to pass around by value efficiently)
You can also loop through all the marines with an iterator like so:
for ( std::vector<CMarine>::iterator _it = marinesList.begin();
_it != marinesList.end(); ++_it );
{
CMarine& marine = *_it;
// Now you can do something with this marine reference
}
UPDATE:
If CMarine is polymorphic, that is, it inherits from a superclass (maybe something like CUnit in your case), and you have a 'global' vector of all units - Georg Fritzsche rightly noted that object slicing could occur (if we are storing by value). Instead you might be better off with a vector of CUnit (smart) pointers like this:
std::vector<std::unique_ptr<CUnit>> unitsList;
// To add a marine:
unitsList.push_back( new CMarine( <whatever-its-constructor-takes> ) );
Read more about vectors here.

Answer 3

Chances are that you don't want a separate container for each of your unit types. Therefore, you'll have to generalise a little and either use something like component based design. Once you have that in place, you'll want an std::vector<GameUnit*> or std::list<GameUnit*> in the first case, and an std::vector<GameUnit> or std::list<GameUnit> in the second case. Either way, you should be using a standard library container to store things.
You can find more information on std::vector and std::list on http://cppreference.com, although your book should already cover them. Also, see

Answer 4

First off, I'd create a Unit class and then subclass your units from it, so you don't have to process a bunch of separate lists. Then, I'd store pointers to the units in:
std::list< Unit * > unitList
A list lets you append however many objects you like, and, while it doesn't allow for rapid access to random members of the list, you can iterate through it easily and not have to worry about it trying to move large amounts of memory around when you delete something out of the middle of it.
One thing I like to do is have a unit register itself with the units list automatically from inside the unit's constructor. So assuming Marine is a subclass of Unit, all I would need to do would be to say:
new Marine(x_pos, y_pos);
...and a new Marine would be created and appended to the list automatically.
At this point, each frame, you can iterate through every Unit in unitList and run the unit's update function (which is a virtual function that is different for each subclass).
After the update loop, run a cleanup loop that iterates through unitsList again, finds all destroyed units, and removes them from the list and deletes them.

Answer 5

I say std::vector ! I usually create a base class of unit (or GameObject as I like to call them) Here's what I would have done:
class GameObject {} // Maybe has virtual methods for the Size, Location and Image?
class Barrack
{
std::vector< GameObject > gameUnits;
public:
// code
void AddUnit() { gameUnits.push_back( GameObject() ); }
void DestroyUnit(int index);
// etc. etc.
}
However, if you don't want to rely too much on inheritance, i.e you have different kinds of units and all of them don't inherit from one base class, you may try this vector_any class I implemented some days ago to hold the sprites of my RPG game:
struct element
{
element( void* data, const std::type_info& info ) : value(data), type( &info ) {}
void* value;
const std::type_info* type;
};
class type_conversion_exception : exception {};
class linked_vector
{
vector< element > stack;
public:
linked_vector() {}
template< typename T > void add_item( T& item )
{
stack.push_back( element( static_cast< void* >( &item ), typeid(item) ) );
}
template< typename T > T& get_item( int index )
{
if ( *( stack[index].type ) == typeid( T ) )
{
return *( static_cast< T* >( stack[index].value ) );
}
else throw type_conversion_exception();
}
};
You can use it for your game units like this.
linked_vector gameUnits;
MilitaryUnit mUnit;
AirUnit aUnit;
gameUnits.add_item( mUnit );
gameUnits.add_item( aUnit );
try{ draw( gameUnits.get_item< MilitaryUnit >(0) ); }
catch( type_conversion_exception e ) { /* error handling */ }
// etc. etc.

Answer 6

The choice between vector and list is a tricky one. Every time you push_back() on the vector, the whole vector is reallocated and copied. A list doesn't have this issue. Neverthless, you could preallocated the vector and have a unit cap - this is fine unless you want effectively 'unlimited' units on a map, but you probably don't.
As for lookup, the vector has constant time lookup for any index, but how often would you want to jump to a particular index? When it comes to iterating over a whole list or vector I don't think there's any performance difference.
Also, when you want to remove a Unit (when it's killed) from a vector you would have some more reallocate and shuffle issues, a list can remove any item much more efficiently.
I'm personally leaning towards a list.
And as already stated the container you choose should hold pointers to the unit base class.