/******************************************************************************
 * SmartPtr class - A template class for creating smart pointers
 *
 *  members: T* ptr: the pointer to the object that has been wrapped
 *
 *****************************************************************************/
template<class T> class SmartPtr {
  T* ptr;
public:
  explicit SmartPtr( T* p = 0 ) : ptr(p) {}; // Gives a default value of 0 to ptr.
  // 'explicit' prevents the use of implicit type conversion in the constuctor  
  ~SmartPtr() { delete ptr; }
  
  T& operator*() const { return *ptr; }
  T* operator->() const { return ptr; }
  
  // The release and reset functions are used for the copy constructors.
  
  T* release() { // Saves the value of ptr, sets it to null, and then returns the old pointer
    T* old_ptr = ptr;
    ptr = 0;
    return old_ptr;
  }
  
  void reset( T* new_ptr ) { // Destroys the old pointer and assigns the new value
    if ( ptr != new_ptr ) {
      delete ptr;
      ptr = new_ptr;
    }
  }
  
  // Copy constructor
  SmartPtr( SmartPtr<T>& other ) : ptr( other.release() ) {}
  
  // Copy assignment operator
  SmartPtr operator=( SmartPtr<T>& other ) {
    if ( this != &other )
      reset( other.release() );
    return *this;
  }
  
};

/******************************************************************************
 * GameMode class - A parent class that all other game mode classes inherit from.
 *
 *  members: 
 *
 *  functions: Update():
 *               A purely virtual function that updates the game status
 *             Render():
 *               A purely virtual function that draws the next frame
 *
 *  notes:
 *****************************************************************************/
class GameMode {
public:
  virtual void Update() = 0;
  virtual void Render() = 0;
};


class BootMode : public GameMode {
public:
  void Update() { cout << "BootMode Update()" << endl; }
  void Render() { cout << "BootMode Render()" << endl; }
  ~BootMode() { cout << "BootMode Destructor" << endl; }
};

class BattleMode : public GameMode {
public:
  void Update() { cout << "BattleMode Update()" << endl; }
  void Render() { cout << "BattleMode Render()" << endl; }
  ~BattleMode() { cout << "BattleMode Destructor" << endl; }
};

class MapMode : public GameMode {
public:
  void Update() { cout << "MapMode Update()" << endl; }
  void Render() { cout << "MapMode Render()" << endl; }
  ~MapMode() { cout << "MapMode Destructor" << endl; }
};

/******************************************************************************
 * GameModeManager class - Contains a stack of GameMode objects for organizing recent game modes.
 *
 *  members: vector<GameMode *> mode_stack: a stack containing all of the current game modes.
 *
 *  functions: Pop():
 *               Removes the top item from the stack and destroys it.
 *             Push():
 *               Puts a new item on the top of the stack.
 *             Update():
 *               Calls the Update function for the GameMode object on the top of the stack
 *             Render():
 *               Calls the Render function for the GameMode object on the top of the stack
 *
 *  notes: 1) The stack should never be empty(?).
 *****************************************************************************/
class GameModeManager {
   vector< SmartPtr<GameMode> > stack;
   int top;
public:
  void Pop() { 
     stack.pop_back();
     if (top != 0)
       top--;
  }
  void Push(SmartPtr<GameMode> gm) { 
//    stack.push_back(gm);
    top++;
  }
   void Update() { (*stack[top]).Update(); }
   void Render() { (*stack[top]).Render(); }

  SmartPtr operator=( SmartPtr<T>& other ) {
    if ( this != &other )
      reset( other.release() );
    return *this;
  }

  SmartPtr<GameMode> p(new BattleMode);
  SmartPtr<GameMode> q;
  q = p;