hello,
in my game, Ive a base class enemy:

class enemy {
 int x, y, r;
 int speed;
 bitmap image;
public:
 ...
};

then, i make new enemies classes like:

class darkstar : public enemy { ... };

the problem is that ALL darkstar have the same image, and this way im using a lot of RAM.
so, since i dont like to use globals I redesigned the classes:

class enemy {
 int x, y, r;
 int speed;
public:
 virtual get_image() = 0;
 ...
};

class darkstar : public enemy {
 static bitmap image;
};
bitmap darkstar::image("mybitmap.bmp"); // this constructor loads a bmp

1)Is this a good design?
2)I cannot load the bitmap image for "darkstar", because the allegro wasnt initialized yet.
This is a big problem!, Im thinking about
a)call allegro_init(); by int cheat = allegro_init(), at first (i dont like this way...)
b)create a one time constructor for darkstar class:
darkstar() : enemy() {
static bool init = false;
if(init) return;
init = true;
image.load("mybitmap.bmp");
}

Help!!

If you use pointers for the BITMAPs allegro don't have to init... and if you don't wanna use globals you can load the image in your enemy manager class

I always have a manager class, that is a singleton, to load in bitmaps. Then just pass them around. That way they are only loaded once.

mnnn, the idea is have a class with ALL the game data, and when any object needs it, it calls the singleton?

class singleton {
 bitmap darkstar_image;
 ...
} singleton;

it needs to be global, right?, (i think I dont understand !)

A Singleton is a design pattern usfull when you only need a single instance of a class.

Making tons of singleton bitmaps is bad a design IMHO .
Also why not make the classes a bit more generic?

Make the BigBad Villan an instance of a Enemy class instead of making the BigBad villan a class himself

Cloned, is a bad word to use here. You will have 1 bitmap loaded into memory and point it to 500 different enemies.

Example of what I do.

CTilesetManager class. This class loads in all bitmaps needed to my map.

CTile class. This class holds bitmaps to show.

CMap class. Holds 2D array of CTile and a CTilesetManger instance. So CTileManager in not global.

not workable but giving the idea:

My system is a small API based around a std::map<string, BITMAP*>. So every time a, say, goblin is created, in its constructor it asks the API for image "goblin". Which the API happily returns a pointer to.

Performance issues? Nah. Obviously, maps are built for fast searching, so a string coughs up a bitmap ASAP. And then the object has the pointer, so performance is kinda a non-issue. Or am I not understanding you?

I create most of the objects betwen levels, but also a lot during the game (bullets, fire particles from the flamethrowers, etc). Hasn't been an issue yet ...

A singleton class is globally available, but you can't make any instances of it outside of the singleton class itself, so there cannot be any global instances of it. Instead you ask the class to give you a reference to an instance that you can use.

It's not good design to have void pointers. The correct way would be to have a base class from where other classes inherit. Then you store pointers to this base class.

You can have a singleton map. It's actually an OOP design pattern, and it's called a dictionary. Using my singleton class from the thread linked by Trezker:

class BitmapDic : public map<string, BITMAP*>, public Singleton<BitmapDic>
{
// nothing here :)
};

[edit]
Or even cooler, you can have a dictionary class:

template <typename K, typename T> class Dictionary: public map<K,T>, public Singleton< Dictionary<K,T> >
{
};

And, to create a dictionary of BITMAP's, with string keys:

class BitmapDic : public Dictionary<string, BITMAP*>
{
};

Make your BITMAP data in this class to be static. Since they all use the same image, it is pointless to have more than one copy of the same image...right?::)

class Enemy
{
public:
Enemy(){pImage=NULL;}
~Enemy(){if(pImage){delete pImage;pImage=NULL;}}
int LoadImage(char *pFileName)
{
pImage = load_bitmap(pFileName,NULL); // truecolor doesn't
// need pallete
if ( !pImage )
return -1;
return 0;
}
static BITMAP *pImage;
};

Simply call LoadImage() after you initialize allegro and setup the graphics system and all will work just fine!;)

Extern isnt related to scope. Extern creates a 'fake' variable so that code can be compiled assuming the variable exsists, not really of much concern with this problem.

I think it might be a better idea if the OP just used the datafile system. Dictionaries and map<>s can be a bit complicated to understand and implement, and if the OP is okay with hardcoded image input (which it appears he/she is) it would make his/her life a lot easier.

Edit:
Its a good idea to add 'Edit' tags if you add something to your post.;)