class IDisplay{    public:        /* All virtual function need to  */        /* have an are derived virtual   */        /* and need to have an         /* implementation in ALL derived */        /* Classes                       */        virtual void update()=0;        virtual void draw()=0;        /* Other pure virtual functions  */        };Class Ring : public IDisplay{   public:     Ring()     ~Ring();     void update(BasePlayer* currPlayer); /* derived as virtual - implementation MUST be given */     void draw(); /* as above */     /* Another derived virtuals - implmentations MUST be provided */     void displayCommentary();     /* Copy constructor - should be included if using heap */     /* Otherwise compiler will provide one if required - and */     /* migth not be the best idea to use e compiler generated one */     Ring(Ring&){} /* if the ring doesn't want to be copied make                      the copy constructor private so if someone tries to                      it will be caught at compile time. Also providing                       this means that the compiler won't generate it's own */     Ring& operator=(Ring& rhs) /* Same as above but for assignment */     {        if (&rhs == this)            return *this;        /* do all member vars : var1 = rhs.var1 etc... */        /* a blank implementation is all that is really needed           cause the overloaded assignment operater is private           so can never be called from outside the class - just           included if you were wonderign what it might look like */     }   private:          char* XDELIM = '-'; /* Use to define boundaries of ring */     char* YDELIM = '|'; /* Use to define boundaries of ring */     char* thisRing[MAXWIDTH][MAXHEIGHT];};

class BasePlayer : public IDisplay{    protected:      /* Vars for All BasePlayer & Derived classes */      /* player state stuff */      enum playerState{OK, HIT, JUMPING, ....other states};      enum healthState(HARD,FINE,NOTBAD,SORE,HURT,VERYBAD,...etc);      playerState m_currState;      bool isCurrPlayer;    public:      BasePlayer();      virtual ~BasePlayer(); /* provide implementaion as it will be called from                                 derived classes, will not compile is missed                                 - even                                 BasePlayer::~BasePlayer(){} will do */          /* copy and assignment constructor and overloaded function if needed     */     /* As this is turned based possibly not as we can utilise shallow        */     /* pointer to class copying in game (usually try to avoid shallow copys) */     bool update(Ring* aRing); /* Implementation MUST be provided - even a blank one as                        with the destructor above */     void draw();   /* as above */     playerState m_getState(){return currState;}     void m_setState(playerState aState){m_currState = aState;}     void m_setHealth(int aDamagePoints){/* Set state accroding to current state + aDamagePoints*/}     /* Positional stuff */      typedef       struct Position      {        int x;        int y;      } position;     int m_getX(){return m_Position.x;}     int m_getY(){return m_position.y;}     struct Position& m_GetPos(){return m_Position;}     void m_setX(int aX){m_Position.x = aX;}     void m_setY(int aY){m_Position.y = aY;}     void m_setPos(struct position& aPos)     {        m_Position.x = aPos.x;        m_Position.y = aPos.y;     }     bool m_isCurrPlayer(){return isCurrPlayer == true;}     void m_setCurrPlayer(bool playFlag){isCurrPlayer = playFlag;}   protected: /* NOT private as derived classes will use it */     position m_Position;          /* BasePlayer player private vars */}/* Human and Computer inherit all the state and positional stuff */class Human : public BasePlayer{   public:     Human();     ~Human();     bool update(Ring* aRing); /* Inherited virtual */     void draw();   /* as above */}class Computer : public BasePlayer{   public:     Computer();     ~Computer();     bool void update(Ring* aRing, Human* aHuman); /* Inherited virtual */     void draw();        /* as above */}

enum playMode {DEMO,HVC,HVH,INST,QUIT,NONE};int menu();void instructions();int main(int argc, char *argv[]){	int mode = 0;		while (mode != QUIT)	{		mode = menu();				switch (mode)		{			case QUIT:			{					char quitYN = ' ';									while(quitYN != 'Y' && quitYN != 'y' && quitYN != 'N' && quitYN != 'n')				{					cout << "\t\tAre you sure? (Y/N): ";					cin >> quitYN;				}									if (quitYN == 'N' || quitYN == 'n')				{					mode = NONE;									}					}					break;			case INST:								instructions();									break;				default:			{				GameEngine *Game = new GameEngine(mode);								Game->Play();								delete Game;				Game=0;			}			break;		}			}	    return EXIT_SUCCESS;}int menu(){	int mode = 0;		CLRSCRN		cout << "\n\t\tMAIN MENU\n";	cout << "\t\t==========\n";	cout << "\n\t1. DEMO - Computer Versus Computer\n";	cout << "\t2. HVC - Human Versus Computer\n";	cout << "\t3. HVH - Human Versus Human\n";	cout << "\t4. Instructions\n";	cout << "\t5. Quit\n";		while (mode < DEMO+1 || mode > QUIT+1)	{		cout << "\n\t\tChoose from option 1-5: ";		cin >> mode;	}		return mode-1;}void instructions(){	cout << "\n\tWelcome to TIC_TAC_TOE\n";	cout << "\n\tMake your move known by entering 1 - 9. The number\n";	cout << "\tcorresponds to the desired board position, as illustrated:\n\n";		cout << "\t1|2|3\n";	cout << "\t-----\n";	cout << "\t4|5|6\n";	cout << "\t-----\n";	cout << "\t7|8|9\n";		cout << "\n\tYou can choose several ways to play from the MAIN MENU or watch a demo\n";	cout << "\tHave a nice game\n";	return;	}

#include <conio.h>while (paused){   char key;   if (!kbhit())   {       key = tolower(getch());						      if (key == 'p')      {          paused = false;      }					   }}

#include <conio.h>while(paused){  char key;    if (!kbhit())  {      switch(key)      {         case 'p':         {            paused = false;         }         break;        default:        {           paused = true;        }        break;      }  }}