BTW just in case you might need a way to fire bullets 'at' a target:

Code:
//An extremely simple Vector2D object
//Is just begging for operator support like addition, subtraction, etc, etc
struct Vector2D
{
  float x;
  float y;
  Vector2D(void):x(0.0f),y(0.0f) { }
  Vector2D(float sx,float sy):x(sx),y(sy) { }
  ...
  ...

};

//Computes direction vector from object to Target
//CObject can be the base and CEnemy and CPlayer can be derived from CObject
//This way you can maintain a list of CObject's and yet gain different functionality in the derived 
//class
void CObject::Target(Vector2D Target)
{
  float fDiffx=m_Pos.x-Target.Pos.x;
  float fDiffy=m_Pos.y-Target.Pos.y;
  fDiffx*=fDiffx;
  fDiffy*=fDiffy;
  float fDist=sqrtf(fDiffx+fDiffy);
  m_FireVector.x=fDiffx/fDist;
  m_FireVector.y=fDiffy/fDist;
}
Code:
//A simple bullet object
struct Bullet
{
  Vector2D vecPos;
  Vector2D vecDirection;
  float fSpeed;
}


//A class that manages a collection or list of bullet objects
class BulletMgr
{
  std::vector<Bullet *> m_vBullets;
  ...
  ...
  public:
   ... 
   void Update();
   ...
};

//Update all bullets in list according to direction and speed
void BulletMgr::Update(void)
{
  for (int i=0;i<iNumBullets;i++)
  {
    m_vBullets[i].Pos.x+=(m_vBullets[i].Direction.x*m_vBullets[i].fSpeed);
    m_vBullets[i].Pos.y+=(m_vBullets[i].Direction.y*m_vBullets[i].fSpeed);
  }
}
Note that I derived everything from CObject. As long as you put most of the important actions and functions in CObject, you can then derive from it to create different types of game objects.

Then you can manage the entire game system using 1 class.

Code:
class CObject {};
class CEnemy::public CObject {};
class CPlayer::public CObject {};
class CWhatever::public CObject {};

class CObjectMgr
{
  std::vector<CObject *> m_vGameObjects;

  public:
    ...
    int Add(CObject *pObject)
    {
       m_vGameObjects.push_back(pObject);
       return static_cast<int>(m_vGameObjects.size()-1);
    }
    ...
};
And then in your drawing class you can now do this:

Code:
class CRenderer
{
   CObjectMgr *m_pObjectMgr;
   ...
};
You can delegate all drawing to each object by first putting:

Code:
virtual void Draw(void);
Inside of the CObject base class and then iterating through the object manager list and calling draw for each one. Your overriden versions of draw for player, enemy, and whatever will be called if you override it. You can provide some base functionality in the base class draw to handle simple drawing of all objects. For objects that need more, you can put that in the derived class's draw() function.

As you can see when you have the power of classes, STL, and DirectX/OpenGL - you can actually make a decent game framework in no time at all.