#include <iostream> //For console output
#include <windows.h>   // WinApi header
using namespace std;
 
#define EMPTY_CELL     177
#define CURSOR     1
#define TAIL     219
#define NUM     6
 
class Room {
private:
 
public:
     bool visited();
     bool active();
     Room(); // Default Constructor
     Room(bool visited, bool active); // Overloaded Constructor
     Room(const Room& node); //  Copy Constructor
     Room& operator= (const Room& node); // Operator
     ~Room(); //  Destructor/Destroyer
 //Mutators
     void setActive (); // Gets the console ready to draw the minesweeper grid
     char draw (); // Draws the grid for minesweeper
};
Room::Room() {
     bool visited = NULL;
     bool active = NULL;
}
 
Room::Room(bool v, bool a) {
     visited = v;
     active = a;
}
 
Room& Room (const Room &node) {
     bool visited = node.visited;
     bool active = node.active;
}
 
Room Room::operator=(const Room& node) {
     this->visited = node.visited;
     this->active = node.active;
     return *this;
}
 
void Room::setActive () {
     this->visited = true;
     this->active = true;
}
 
char Room::draw () {
     char ch = char (EMPTY_CELL);
     if (visited) {
     ch = char (TAIL);
     }
     if (this->active) {
          ch = char (CURSOR);
          this->active = false;
     }
     return ch;
}
 
Room::~Room () {
}
/************************************************************************************************/
 
#define MIN_COL  2  //minimum size allowed for number of columns
#define MIN_ROW 2  //minimum size allowed for number of rows
#define MIN_DEPTH 2  //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE     205
#define RIGHT_UPPER_CORNER     187
#define LEFT_LOWER_CORNER     200
#define RIGHT_LOWER_CORNER     188
#define INTERSECTION     206
#define VERTICAL_WITH_RIGHT_TURN     204
#define VERTICAL_WITH_LEFT_TURN     185
#define HORIZONTAL_WITH_DOWN_LINE     203
#define HORIZONTAL_WITH_UP_LINE     202
#define RROW 11;
#define RCOL 11;
#define EMPTY_CELL     177
#define CURSOR     1
#define TAIL     219
#define NUM     6
 
 
class Dynamic3DArray {
 
 
protected:
     int ROW;
     int COL;
     int DEPTH;
     Room** array;
public:
     Dynamic3DArray (); // Default Consturtor
     Dynamic3DArray (int row, int col, int depth); // Overloaded Constructor
     Dynamic3DArray (const Dynamic3DArray& dynamic3DArray); // Copy Constructor
     Dynamic3DArray& operator= (const Dynamic3DArray& dynamic3DArray); //Assignment Operator
     ~Dynamic3DArray (); //Destroyer/Destructor
//Accessors
     int getROW (); //Gets the number of rows
     int getCOL (); //Gets the number of columns
     int getDEPTH (); //Gets the number for the depth
//Mutators
     void create (); //Will create a 3Dimentional grid
     void destroy (); //Destroys the grid to free memory
     void setActive (int x, int y, int z); //Will make the cells visited
     bool setDimentions (); //Will set the dimentions of the grid
     void resize (int x, int y, int z); //Will change the dimentions of the grid
     void print (int depth); //This prints the grid with the depth given by user
     void printDimentions (int x, int y, int z); //This prints the overall grid
};
 
Dynamic3DArray::Dynamic3DArray () {
     this-> ROW = 0;
     this-> COL = 0;
     this-> DEPTH = 0;
     array = NULL;
}
 
void Dynamic3DArray::create () {
     array = new Room**[ROW];
     for (int r=0; r<ROW; r++); {
     array[r] = new Room*[COL];
     for (int c=0; c<COL; c++) 
     array[r][c] = new Room[DEPTH];
     }
}
 
void Dynamic3DArray::destroy () {
     for (int r=0; r<ROW; r++) {
     for (int c=0; c<COL; c++)
     delete [] array [r][c];
     delete [] array [r];
     }
     delete [] array;
}
 
Dynamic3DArray::Dynamic3DArray (int row, int col, int depth) {
     this-> ROW = row;
     this-> COL = col;
     this-> DEPTH = depth;
     create ();
}
 
Dynamic3DArray::Dynamic3DArray (const Dynamic3DArray& dynamic3DArray) {
     this-> ROW = dynamic3DArray.ROW;
     this-> COL = dynamic3DArray.COL;
     this-> DEPTH = dynamic3DArray.DEPTH;
     create ();
}
 
void Dynamic3DArray::setActive (int x, int y, int z) {
     this-> array [x-1][y-1][z-1].setActive ();
}
 
void Dynamic3DArray::printDimentions (int x, int y, int z) {
     cout << "   < " << x << "," << y << "," << z << ">" << endl << endl;
}
 
void Dynamic3DArray::resize (int r, int c, int d) {
     Dynamic3DArray temp (*this);
     temp = *this;
     this-> destroy ();
     this-> ROW = r;
     this-> COL = c;
     this-> DEPTH = d;
     this-> create ();
     if (temp.ROW<ROW) {
          for (int r=0; r<temp.ROW; r++) {
               for (int c=0; c<temp.COL; c++) {
                    for (int d=0; d<temp.DEPTH; d++)
                    this-> array[r+1][c+1][d+1]=temp.array[r][c][d];
               }
          }
     }
     else {
          for (int r=0; r<temp.ROW; r++) {
               for (int c=0; c<COL; c++) {
                    for (int d=0; d<DEPTH; d++) {
                         this->array[r][c][d]=temp.array[r+1][c+1][d+1];
                    }
               }
          }
     }
}
int Dynamic3DArray::getROW () {
     return this-> ROW;
}
int Dynamic3DArray::getCOL () {
     return this-> COL;
}
int Dynamic3DArray::getDEPTH () {
     return this->DEPTH;
}
Dynamic3DArray::~Dynamic3DArray () {
     destroy ();
}
Dynamic3DArray& Dynamic3DArray::operator=(const Dynamic3DArray& dynamic3DArray) {
 destroy ();
     this->ROW = dynamic3DArray.ROW;
     this->COL = dynamic3DArray.COL;
     this->DEPTH = dynamic3DArray.DEPTH;
     create ();
     for (int r=0; r<ROW; r++) {
          for (int c=0; c<COL; c++) {
               for (int d=0; d<DEPTH; d++)
              array[r][c][d]=dynamic3DArray.array[r][c][d];
          }
     }
     return *this;
}
void Dynamic3DArray::print (int depth) {
     system ("cls");
     cout << char (LEFT_UPPER_CORNER);
          for (int r=0; r<ROW; r++) {
          cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_DOWN_LINE);
          }
          cout << "\b" << char (RIGHT_UPPER_CORNER) << endl;
          for (int c=0; c<COL; c++) {
               cout << char (VERTICAL_LINE);
                    for (int r=0; r<ROW; r++) {
                         cout << array[r][c][depth-1].draw () << char (VERTICAL_LINE);
                    }
                    cout << "\b" << char (VERTICAL_WITH_RIGHT_TURN);
                    if (c< (COL-1)) {
                         for (int i=0; i<ROW; i++) {
                              cout << char (HORIZONTAL_LINE) << char (INTERSECTION);
                         }
                         cout << "\b" << char (VERTICAL_WITH_LEFT_TURN) << "\n";
                    }
                    else {
                         cout << "\b" << char (LEFT_LOWER_CORNER);
                         for (int r=0; r<ROW; r++) {
                              cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_UP_LINE);
                         }
                    }
               }
 cout << "\b" << char (RIGHT_LOWER_CORNER) << "\n";
}
 
/************************************************************************************************/
#define MIN_COL  2  //minimum size allowed for number of columns
#define MIN_ROW 2  //minimum size allowed for number of rows
#define MIN_DEPTH 2  //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE     205
#define RIGHT_UPPER_CORNER     187
#define LEFT_LOWER_CORNER     200
#define RIGHT_LOWER_CORNER     188
#define INTERSECTION     206
#define VERTICAL_WITH_RIGHT_TURN     204
#define VERTICAL_WITH_LEFT_TURN     185
#define HORIZONTAL_WITH_DOWN_LINE     203
#define HORIZONTAL_WITH_UP_LINE     202
#define RROW 11;
#define RCOL 11;
#define NUM     6
 
 
class GridActive:Dynamic3DArray {
private:
     int x;
     int y;
     int z;
public:
     GridActive::GridActive ():Dynamic3DArray ();
     GridActive (int R, int C, int D);
     GridActive (const GridActive & grid);
     ~GridActive ();
 
//Accessors
     bool goNorth ();
     bool goSouth ();
     bool goWest ();
     bool goEast ();
     bool goUp ();
     bool goDown ();
     int getRow ();
     int getCol ();
     int getDepth ();
     int getX ();
     int getY ();
     int getZ ();
//Mutators
     void upsize ();
     void downsize ();
     void setActive ();
     void printDimentions (int x, int y, int z);
     void print (int dep);
     void GridActive::setActive (int x, int y, int z);
};
GridActive::GridActive ():Dynamic3DArray () {
     x=0;
     y=0;
     z=0;
}
GridActive::GridActive (int R, int C, int D):Dynamic3DArray (R, C, D) {
     x=1;
     y=1;
     z=1;
}
 
GridActive::~GridActive () {
}
 
GridActive::GridActive (const GridActive & grid):Dynamic3DArray(grid) {
}
 
GridActive& GridActive::operator= (const GridActive & grid) {
     destroy ();
     this->x = grid.x;
     this->y = grid.y;
     this->z = grid.z;
     this->ROW = grid.ROW;
     this->COL = grid.COL;
     this->DEPTH = grid.DEPTH;
     create ();
     int*** array = new int**[DEPTH];
     for (int r=0; r<ROW; r++) {
           for (int c=0; c<COL; c++) {
                for (int d=0; d<DEPTH; d++)
                array[r][c][d] = grid.array[r][c][d];
           }
     }
     return *this;
}
 
bool GridActive::goNorth () {
     if (y == 1) return false;
     y--;
     return true;
}
 
bool GridActive::goSouth () {
     if (y == COL) return false;
     y++;
     return true;
}
 
bool GridActive::goDown () {
     if (z == 1) return false;
     z--;
     return true;
}
 
bool GridActive::goUp () {
     if (z == DEPTH) return false;
     z++;
     return true;
}
bool GridActive::goEast () {
     if (x == ROW) return false;
     x++;
     return true;
}
 
bool GridActive::goWest () {
     if (x == 1) return false;
     x--;
     return true;
}
int GridActive::getRow () {
     return ROW;
}
int GridActive::getCol () {
     return COL;
}
int GridActive::getDepth () {
     return DEPTH;
}
void GridActive::print (int dep) {
     Dynamic3DArray::print (dep);
}
int GridActive::getX () {
     return x;
}
int GridActive::getY () {
     return y;
}
int GridActive::getZ () {
     return z;
}
void GridActive::setActive (int x, int y, int z) {
     Dynamic3DArray::setActive (x, y, z);
}
void GridActive::printDimentions (int x, int y, int z) {
     Dynamic3DArray::printDimentions (x, y, z);
}
void GridActive::upsize() {
     if ((ROW< MAX_ROW-2) && (COL<MAX_COL-2) && (DEPTH< MAX_DEPTH-2)) {
          resize (this->ROW+2, this->COL+2, this->DEPTH+2);
          x++;
          y++;
          z++;
     }
}
void GridActive::downsize () {
     if (ROW > MIN_ROW && COL > MIN_COL && DEPTH > MIN_DEPTH &&
  this->x != this->y !=1 && this->z !=1 &&
  this->x != this->ROW && this->y != this->COL && this->z != DEPTH) {
          resize (this->ROW-2, this->COL-2, this->DEPTH-2);
          x--;
          y--;
          z--;
     }
}
 
 
void printEnd() {
     system ("cls");
     cout << "XXXXXXXXXXXXXXX  XX     XX      XXX      XXXXX      XXX  XXX     XXX     XXX      XXX    XXXXX         XXX     XXX" << endl;
     cout << "XXXXXXXXXXXXXXX  XX     XX     XXXXX     XXXXXX     XXX  XXX   XXX       XXX    XXX    XXX   XXX     XXX     XXX" << endl;
     cout << "      XXX       XX     XX    XXX XXX    XXX XXX    XXX  XXX  XXX        XXX  XXX    XXX       XXX XXX     XXX" << endl;
     cout << "      XXX       XXXXXXXXX   XXX   XXX   XXX  XXX   XXX  XXXXXXX        XXXXX     XXX           XXX XXX     XXX" << endl;
     cout << "      XXX       XXXXXXXXX   XXXXXXXXX   XXX   XXX  XXX  XXXXXXX        XXXX      XXX           XXX XXX     XXX" << endl;
     cout << "      XXX       XX     XX  XXXXXXXXXXX  XXX    XXX XXX  XXX   XXX        XXX         XXX        XXX   XXX     XXX" << endl;
     cout << "      XXX       XX     XX  XXX     XXX  XXX     XXXXXX  XXX    XXX    XXX           XXX   XXX      XXX   XXX " << endl;
     cout << "      XXX       XX     XX  XXX     XXX  XXX      XXXXX  XXX     XXX    XXX             XXXXX           XXXXXX  " << endl;
     cout << "                                                                                                                " << endl;
     cout << "XXXXXXXXXX     XXXXX       XXXXXXXX     XXXXXXXX    XX          X     XX     XXX XX XXX       XX       XXXXXXX  " << endl;
     cout << "XXXXXXXXXX   XXX   XXX     XXXXXXXXX     XXX   XXXX  XX         XXX    XX   XXX   XX XXXX      XX    XXXXX    XX " << endl;
     cout << "XXX     XXX       XXX   XXX    XXX      XXX      XX XX        XXXXX   XX XXX     XX XX XX     XX  XXXX          " << endl;
     cout << "XXXXXX   XXX           XXX XXX   XXX     XXX    XXX  XX       XX  XXX  XXXX      XX XX  XX    XX XXX            " << endl;
     cout << "XXXXXX   XXX           XXX XXXXXXXX     XXXXXXX     XX       XXXXXXX  XXX      XX XX   XX   XX XXX       XXXXX" << endl;
     cout << "XXX     XXX       XXX   XXX  XXX     XXX         XX     XXXXXXXXX XXX        XX XX    XX  XX  XXXX       XXX" << endl;
     cout << "XXX       XXX   XXX     XXX   XXX     XXX         XXXXXXX XX    XXX XXX        XX XX     XXXXX    XXXXXXXXXX  " << endl;
     cout << "XXX         XXXXX       XXX    XXX     XXX         XXXXXXX XX    XXX XXX        XX XX      XXXX       XXXXXX   " << endl;
}
 
void main () {
     HANDLE  hConsole;
     int k;
 
     hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
 
     for(k = 1; k < 2; k++) {
          SetConsoleTextAttribute(hConsole, 26);
          char keyPressed;
          bool quit = false;
          int dX;
          int dY;
          int dZ;
          do {
              system("cls");
              cout <<endl;
              cout <<endl;
              cout <<"xxxx___xxxx__xx__xxx____xxx__xxxxxx___xxxxxx___xxx___________xxx__xxxxxx__xxxxxx__xxxxx_____xxxxxx__xxxxxx" << endl;
              cout <<"xxxx___xxxx__xx__xxxx___xxx__xxxxxx__xxxxxxxx__xxx___________xxx__xxxxxx__xxxxxx__xxxxxxx___xxxxxx__xxxxxxx"<< endl;
              cout <<"xxxxx_xxxxx__xx__xxxx___xxx__xx______xxx__xxx__xxx___________xxx__xx______xx______xx___xxx__xx______xx___xx"<< endl;
              cout <<"xxx_xxx_xxx__xx__xxxxx__xxx__xx______xxx________xxx_________xxx___xx______xx______xx___xxx__xx______xx___xx"<< endl;
              cout <<"xxx_xxx_xxx__xx__xxx_xx_xxx__xxxxx____xxx_______xxx____x____xxx___xxxxx___xxxxx___xxxxxxx___xxxxx___xxxxxx"<< endl;
              cout <<"xxx__x__xxx__xx__xxx__xxxxx__xxxxx______xxx______xxx___x___xxx____xxxxx___xxxxx___xxx_______xxxxx___xxxx"<< endl;
              cout <<"xxx_____xxx__xx__xxx__xxxxx__xx___________xxx____xxx__xxx__xxx____xx______xx______xx________xx______xx_xx"<< endl;
              cout <<"xxx_____xxx__xx__xxx___xxxx__xx______xxx__xxx_____xxxx___xxxx_____xx______xx______xx________xx______xx__xx"<< endl;
              cout <<"xxx_____xxx__xx__xxx____xxx__xxxxxx__xxxxxxxx_____xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx"<< endl;
              cout <<"xxx_____xxx__xx__xxx____xxx__xxxxxx___xxxxxx______xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx"<< endl;
              cout << endl << endl << endl;
              system("pause");
 
             cout <<"  You may use the ESC button to quit MINESWEEPER anytime you wish" << endl;
             cout <<"  The arrow buttons on your keyboard will be used to move your player around" << endl;
             cout <<"  The buttons < and > will be used to go up and down levels" << endl;
             cout <<"  The buttons = or - will be used to increse or decrease the size of your game" << endl;
             system("pause");
             cout << "  Enter the number of rows you would like to have" << endl;
             cin >> dX;
             while (dX > MAX_ROW) {
                  cout << " Please re-enter the number of rows you would like that is less than your previous entry" << endl;
                  cin >> dX;
             }
             while (dX < MIN_ROW) {
                  cout << " Please re-enter the number of rows you would like that is greater than your previous entry" << endl;
                  cin >> dX;
             }
             cout << " Enter the number of columns you would like to have" << endl;
             cin >> dY;
             while (dY > MAX_COL) {
                  cout << " Please re-enter the number of columns you would like that is less than your previous entry" << endl;
                  cin >> dY;
             }
             while (dY < MIN_COL) {
                  cout << " Please re-enter the number of columns you would like that is greater than your previous entry" << endl;
                  cin >> dY;
             }
             cout << " Enter the depth you would like to have" << endl;
             cin >> dZ;
             while (dZ > MAX_DEPTH) {
                  cout << " Please re-enter the depth you would like that is less than your previous entry" << endl;
                  cin >> dZ;
             }
             while (dZ < MIN_DEPTH) {
              cout << " Please re-enter the depth you would like that is greater than your previous entry" << endl;
              cin >> dZ;
             }
 
             GridActive myGridActive (dX, dY, dZ);
 
             do{
                   myGridActive.setActive ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ());
                   myGridActive.print (myGridActive.getZ());
                   myGridActive.printDimensions ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ() );
                   myGridActive.printDimensions ( myGridActive.getRow(), myGridActive.getCol(), myGridActive.getDepth() );
                   keyPressed = toascii ( getch() );
                   switch (keyPressed)
                   {
                        case 27 : quit = true; break;
                        case 44 : myGridActive.goDown (); break;
                        case 46 : myGridActive.goUp (); break;
                        case 61 : myGridActive.upsize (); break;
                        case 99 : system ("cls"); break;
                        case 45 : myGridActive.downsize (); break;
                        case 96 : {
                             keyPressed = toascii (getch() );
                             switch (keyPressed)
                             {
                                  case 72 : myGridActive.goNorth (); break;
                                  case 80 : myGridActive.goSouth (); break;
                                  case 75 : myGridActive.goWest (); break;
                                  case 77 : myGridActive.goEast (); break;
                                  default: break;
                             }
                             default: break:
                        }
                   }
              }
              while (!quit);
              cout << "\n Would you like to start over? Press any key \n  Would you like to quit? Press N ";
              keyPressed = getch ();
              quit = false;
              if (( keyPressed == 'N' ) || (keyPressed == 'n' ))
              quit = true;
         }
         cin.get(); // wait
         return 0;
         while (!quit);
     printEnd();
}

i get the following errors i cannot seem to fix

--------------------Configuration: game101new - Win32 Debug--------------------
Compiling...
game101new.cpp
line 44 : error C2659: '=' : overloaded function as left operand
line 45 : error C2659: '=' : overloaded function as left operand
line 55 : error C2143: syntax error : missing ';' before 'tag::id'
line 55 : error C2501: 'Room' : missing storage-class or type specifiers
line 55 : error C2373: 'Room' : redefinition; different type modifiers
line 49 : see declaration of 'Room'
line 55 : fatal error C1004: unexpected end of file found
Error executing cl.exe.
game101new.exe - 6 error(s), 0 warning(s)

>>Room& Room (const Room &node) {
constructors do not have return values. And you forgot the class scope operator. It should be like this:

Room::Room (const Room &node) {

>>Room Room::operator=(const Room& node) {

you forgot the reference operator in the return type

which line is line 44?

bool visited();
     bool active();

Why are you declaring these members with () when you try to access them as data here:

Room& Room (const Room &node) {
     bool visited = node.visited;
     bool active = node.active;
}

Perhaps you meant member data, but accidently added () after the name.

#include <iostream> //For console output
#include <windows.h>   // WinApi header
using namespace std;
 
#define EMPTY_CELL     177
#define CURSOR     1
#define TAIL     219
#define NUM     6
 
class Room {

public:
     bool visited;
     bool active;
     Room(); // Default Constructor
     Room(bool visited, bool active); // Overloaded Constructor
     Room(const Room& node); //  Copy Constructor
     Room& operator= (const Room& node); // Operator
     ~Room(); //  Destructor/Destroyer
 //Mutators
     void setActive (); // Gets the console ready to draw the minesweeper grid
     char draw (); // Draws the grid for minesweeper
};
Room::Room() {
     bool visited = NULL;
     bool active = NULL;
}
 
Room::Room(bool v, bool a) {
     visited = v;
     active = a;
}
 
Room& Room (const Room &node) {
     bool visited = node.visited;
     bool active = node.active;
}
 
Room::Room operator=(const Room& node) {
     this->visited = node.visited;
     this->active = node.active;
     return *this;
}
 
void Room::setActive () {
     this->visited = true;
     this->active = true;
}
 
char Room::draw () {
     char ch = char (EMPTY_CELL);
     if (visited) {
     ch = char (TAIL);
     }
     if (this->active) {
          ch = char (CURSOR);
          this->active = false;
     }
     return ch;
}
 
Room::~Room () {
}
/************************************************************************************************/
 
#define MIN_COL  2  //minimum size allowed for number of columns
#define MIN_ROW 2  //minimum size allowed for number of rows
#define MIN_DEPTH 2  //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE     205
#define RIGHT_UPPER_CORNER     187
#define LEFT_LOWER_CORNER     200
#define RIGHT_LOWER_CORNER     188
#define INTERSECTION     206
#define VERTICAL_WITH_RIGHT_TURN     204
#define VERTICAL_WITH_LEFT_TURN     185
#define HORIZONTAL_WITH_DOWN_LINE     203
#define HORIZONTAL_WITH_UP_LINE     202
#define RROW 11;
#define RCOL 11;
#define EMPTY_CELL     177
#define CURSOR     1
#define TAIL     219
#define NUM     6
 
 
class Dynamic3DArray {
 
 
protected:
     int ROW;
     int COL;
     int DEPTH;
     Room** array;
public:
     Dynamic3DArray (); // Default Consturtor
     Dynamic3DArray (int row, int col, int depth); // Overloaded Constructor
     Dynamic3DArray (const Dynamic3DArray& dynamic3DArray); // Copy Constructor
     Dynamic3DArray& operator= (const Dynamic3DArray& dynamic3DArray); //Assignment Operator
     ~Dynamic3DArray (); //Destroyer/Destructor
//Accessors
     int getROW (); //Gets the number of rows
     int getCOL (); //Gets the number of columns
     int getDEPTH (); //Gets the number for the depth
//Mutators
     void create (); //Will create a 3Dimentional grid
     void destroy (); //Destroys the grid to free memory
     void setActive (int x, int y, int z); //Will make the cells visited
     bool setDimentions (); //Will set the dimentions of the grid
     void resize (int x, int y, int z); //Will change the dimentions of the grid
     void print (int depth); //This prints the grid with the depth given by user
     void printDimentions (int x, int y, int z); //This prints the overall grid
};
 
Dynamic3DArray::Dynamic3DArray () {
     this-> ROW = 0;
     this-> COL = 0;
     this-> DEPTH = 0;
     array = NULL;
}
 
void Dynamic3DArray::create () {
     array = new Room**[ROW];
     for (int r=0; r<ROW; r++); {
     array[r] = new Room*[COL];
     for (int c=0; c<COL; c++) 
     array[r][c] = new Room[DEPTH];
     }
}
 
void Dynamic3DArray::destroy () {
     for (int r=0; r<ROW; r++) {
     for (int c=0; c<COL; c++)
     delete [] array [r][c];
     delete [] array [r];
     }
     delete [] array;
}
 
Dynamic3DArray::Dynamic3DArray (int row, int col, int depth) {
     this-> ROW = row;
     this-> COL = col;
     this-> DEPTH = depth;
     create ();
}
 
Dynamic3DArray::Dynamic3DArray (const Dynamic3DArray& dynamic3DArray) {
     this-> ROW = dynamic3DArray.ROW;
     this-> COL = dynamic3DArray.COL;
     this-> DEPTH = dynamic3DArray.DEPTH;
     create ();
}
 
void Dynamic3DArray::setActive (int x, int y, int z) {
     this-> array [x-1][y-1][z-1].setActive ();
}
 
void Dynamic3DArray::printDimentions (int x, int y, int z) {
     cout << "   < " << x << "," << y << "," << z << ">" << endl << endl;
}
 
void Dynamic3DArray::resize (int r, int c, int d) {
     Dynamic3DArray temp (*this);
     temp = *this;
     this-> destroy ();
     this-> ROW = r;
     this-> COL = c;
     this-> DEPTH = d;
     this-> create ();
     if (temp.ROW<ROW) {
          for (int r=0; r<temp.ROW; r++) {
               for (int c=0; c<temp.COL; c++) {
                    for (int d=0; d<temp.DEPTH; d++)
                    this-> array[r+1][c+1][d+1]=temp.array[r][c][d];
               }
          }
     }
     else {
          for (int r=0; r<temp.ROW; r++) {
               for (int c=0; c<COL; c++) {
                    for (int d=0; d<DEPTH; d++) {
                         this->array[r][c][d]=temp.array[r+1][c+1][d+1];
                    }
               }
          }
     }
}
int Dynamic3DArray::getROW () {
     return this-> ROW;
}
int Dynamic3DArray::getCOL () {
     return this-> COL;
}
int Dynamic3DArray::getDEPTH () {
     return this->DEPTH;
}
Dynamic3DArray::~Dynamic3DArray () {
     destroy ();
}
Dynamic3DArray& Dynamic3DArray::operator=(const Dynamic3DArray& dynamic3DArray) {
 destroy ();
     this->ROW = dynamic3DArray.ROW;
     this->COL = dynamic3DArray.COL;
     this->DEPTH = dynamic3DArray.DEPTH;
     create ();
     for (int r=0; r<ROW; r++) {
          for (int c=0; c<COL; c++) {
               for (int d=0; d<DEPTH; d++)
              array[r][c][d]=dynamic3DArray.array[r][c][d];
          }
     }
     return *this;
}
void Dynamic3DArray::print (int depth) {
     system ("cls");
     cout << char (LEFT_UPPER_CORNER);
          for (int r=0; r<ROW; r++) {
          cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_DOWN_LINE);
          }
          cout << "\b" << char (RIGHT_UPPER_CORNER) << endl;
          for (int c=0; c<COL; c++) {
               cout << char (VERTICAL_LINE);
                    for (int r=0; r<ROW; r++) {
                         cout << array[r][c][depth-1].draw () << char (VERTICAL_LINE);
                    }
                    cout << "\b" << char (VERTICAL_WITH_RIGHT_TURN);
                    if (c< (COL-1)) {
                         for (int i=0; i<ROW; i++) {
                              cout << char (HORIZONTAL_LINE) << char (INTERSECTION);
                         }
                         cout << "\b" << char (VERTICAL_WITH_LEFT_TURN) << "\n";
                    }
                    else {
                         cout << "\b" << char (LEFT_LOWER_CORNER);
                         for (int r=0; r<ROW; r++) {
                              cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_UP_LINE);
                         }
                    }
               }
 cout << "\b" << char (RIGHT_LOWER_CORNER) << "\n";
}
 
/************************************************************************************************/
#define MIN_COL  2  //minimum size allowed for number of columns
#define MIN_ROW 2  //minimum size allowed for number of rows
#define MIN_DEPTH 2  //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE     205
#define RIGHT_UPPER_CORNER     187
#define LEFT_LOWER_CORNER     200
#define RIGHT_LOWER_CORNER     188
#define INTERSECTION     206
#define VERTICAL_WITH_RIGHT_TURN     204
#define VERTICAL_WITH_LEFT_TURN     185
#define HORIZONTAL_WITH_DOWN_LINE     203
#define HORIZONTAL_WITH_UP_LINE     202
#define RROW 11;
#define RCOL 11;
#define NUM     6
 
 
class GridActive:Dynamic3DArray {
private:
     int x;
     int y;
     int z;
public:
     GridActive::GridActive ():Dynamic3DArray ();
     GridActive (int R, int C, int D);
     GridActive (const GridActive & grid);
     ~GridActive ();
 
//Accessors
     bool goNorth ();
     bool goSouth ();
     bool goWest ();
     bool goEast ();
     bool goUp ();
     bool goDown ();
     int getRow ();
     int getCol ();
     int getDepth ();
     int getX ();
     int getY ();
     int getZ ();
//Mutators
     void upsize ();
     void downsize ();
     void setActive ();
     void printDimentions (int x, int y, int z);
     void print (int dep);
     void GridActive::setActive (int x, int y, int z);
};
GridActive::GridActive ():Dynamic3DArray () {
     x=0;
     y=0;
     z=0;
}
GridActive::GridActive (int R, int C, int D):Dynamic3DArray (R, C, D) {
     x=1;
     y=1;
     z=1;
}
 
GridActive::~GridActive () {
}
 
GridActive::GridActive (const GridActive & grid):Dynamic3DArray(grid) {
}
 
GridActive& GridActive::operator= (const GridActive & grid) {
     destroy ();
     this->x = grid.x;
     this->y = grid.y;
     this->z = grid.z;
     this->ROW = grid.ROW;
     this->COL = grid.COL;
     this->DEPTH = grid.DEPTH;
     create ();
     int*** array = new int**[DEPTH];
     for (int r=0; r<ROW; r++) {
           for (int c=0; c<COL; c++) {
                for (int d=0; d<DEPTH; d++)
                array[r][c][d] = grid.array[r][c][d];
           }
     }
     return *this;
}
 
bool GridActive::goNorth () {
     if (y == 1) return false;
     y--;
     return true;
}
 
bool GridActive::goSouth () {
     if (y == COL) return false;
     y++;
     return true;
}
 
bool GridActive::goDown () {
     if (z == 1) return false;
     z--;
     return true;
}
 
bool GridActive::goUp () {
     if (z == DEPTH) return false;
     z++;
     return true;
}
bool GridActive::goEast () {
     if (x == ROW) return false;
     x++;
     return true;
}
 
bool GridActive::goWest () {
     if (x == 1) return false;
     x--;
     return true;
}
int GridActive::getRow () {
     return ROW;
}
int GridActive::getCol () {
     return COL;
}
int GridActive::getDepth () {
     return DEPTH;
}
void GridActive::print (int dep) {
     Dynamic3DArray::print (dep);
}
int GridActive::getX () {
     return x;
}
int GridActive::getY () {
     return y;
}
int GridActive::getZ () {
     return z;
}
void GridActive::setActive (int x, int y, int z) {
     Dynamic3DArray::setActive (x, y, z);
}
void GridActive::printDimentions (int x, int y, int z) {
     Dynamic3DArray::printDimentions (x, y, z);
}
void GridActive::upsize() {
     if ((ROW< MAX_ROW-2) && (COL<MAX_COL-2) && (DEPTH< MAX_DEPTH-2)) {
          resize (this->ROW+2, this->COL+2, this->DEPTH+2);
          x++;
          y++;
          z++;
     }
}
void GridActive::downsize () {
     if (ROW > MIN_ROW && COL > MIN_COL && DEPTH > MIN_DEPTH &&
  this->x != this->y !=1 && this->z !=1 &&
  this->x != this->ROW && this->y != this->COL && this->z != DEPTH) {
          resize (this->ROW-2, this->COL-2, this->DEPTH-2);
          x--;
          y--;
          z--;
     }
}
 
 
void printEnd() {
     system ("cls");
     cout << "XXXXXXXXXXXXXXX  XX     XX      XXX      XXXXX      XXX  XXX     XXX     XXX      XXX    XXXXX         XXX     XXX" << endl;
     cout << "XXXXXXXXXXXXXXX  XX     XX     XXXXX     XXXXXX     XXX  XXX   XXX       XXX    XXX    XXX   XXX     XXX     XXX" << endl;
     cout << "      XXX       XX     XX    XXX XXX    XXX XXX    XXX  XXX  XXX        XXX  XXX    XXX       XXX XXX     XXX" << endl;
     cout << "      XXX       XXXXXXXXX   XXX   XXX   XXX  XXX   XXX  XXXXXXX        XXXXX     XXX           XXX XXX     XXX" << endl;
     cout << "      XXX       XXXXXXXXX   XXXXXXXXX   XXX   XXX  XXX  XXXXXXX        XXXX      XXX           XXX XXX     XXX" << endl;
     cout << "      XXX       XX     XX  XXXXXXXXXXX  XXX    XXX XXX  XXX   XXX        XXX         XXX        XXX   XXX     XXX" << endl;
     cout << "      XXX       XX     XX  XXX     XXX  XXX     XXXXXX  XXX    XXX    XXX           XXX   XXX      XXX   XXX " << endl;
     cout << "      XXX       XX     XX  XXX     XXX  XXX      XXXXX  XXX     XXX    XXX             XXXXX           XXXXXX  " << endl;
     cout << "                                                                                                                " << endl;
     cout << "XXXXXXXXXX     XXXXX       XXXXXXXX     XXXXXXXX    XX          X     XX     XXX XX XXX       XX       XXXXXXX  " << endl;
     cout << "XXXXXXXXXX   XXX   XXX     XXXXXXXXX     XXX   XXXX  XX         XXX    XX   XXX   XX XXXX      XX    XXXXX    XX " << endl;
     cout << "XXX     XXX       XXX   XXX    XXX      XXX      XX XX        XXXXX   XX XXX     XX XX XX     XX  XXXX          " << endl;
     cout << "XXXXXX   XXX           XXX XXX   XXX     XXX    XXX  XX       XX  XXX  XXXX      XX XX  XX    XX XXX            " << endl;
     cout << "XXXXXX   XXX           XXX XXXXXXXX     XXXXXXX     XX       XXXXXXX  XXX      XX XX   XX   XX XXX       XXXXX" << endl;
     cout << "XXX     XXX       XXX   XXX  XXX     XXX         XX     XXXXXXXXX XXX        XX XX    XX  XX  XXXX       XXX" << endl;
     cout << "XXX       XXX   XXX     XXX   XXX     XXX         XXXXXXX XX    XXX XXX        XX XX     XXXXX    XXXXXXXXXX  " << endl;
     cout << "XXX         XXXXX       XXX    XXX     XXX         XXXXXXX XX    XXX XXX        XX XX      XXXX       XXXXXX   " << endl;
}
 
void main () {
     HANDLE  hConsole;
     int k;
 
     hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
 
     for(k = 1; k < 2; k++) {
          SetConsoleTextAttribute(hConsole, 26);
          char keyPressed;
          bool quit = false;
          int dX;
          int dY;
          int dZ;
          do {
              system("cls");
              cout <<endl;
              cout <<endl;
              cout <<"xxxx___xxxx__xx__xxx____xxx__xxxxxx___xxxxxx___xxx___________xxx__xxxxxx__xxxxxx__xxxxx_____xxxxxx__xxxxxx" << endl;
              cout <<"xxxx___xxxx__xx__xxxx___xxx__xxxxxx__xxxxxxxx__xxx___________xxx__xxxxxx__xxxxxx__xxxxxxx___xxxxxx__xxxxxxx"<< endl;
              cout <<"xxxxx_xxxxx__xx__xxxx___xxx__xx______xxx__xxx__xxx___________xxx__xx______xx______xx___xxx__xx______xx___xx"<< endl;
              cout <<"xxx_xxx_xxx__xx__xxxxx__xxx__xx______xxx________xxx_________xxx___xx______xx______xx___xxx__xx______xx___xx"<< endl;
              cout <<"xxx_xxx_xxx__xx__xxx_xx_xxx__xxxxx____xxx_______xxx____x____xxx___xxxxx___xxxxx___xxxxxxx___xxxxx___xxxxxx"<< endl;
              cout <<"xxx__x__xxx__xx__xxx__xxxxx__xxxxx______xxx______xxx___x___xxx____xxxxx___xxxxx___xxx_______xxxxx___xxxx"<< endl;
              cout <<"xxx_____xxx__xx__xxx__xxxxx__xx___________xxx____xxx__xxx__xxx____xx______xx______xx________xx______xx_xx"<< endl;
              cout <<"xxx_____xxx__xx__xxx___xxxx__xx______xxx__xxx_____xxxx___xxxx_____xx______xx______xx________xx______xx__xx"<< endl;
              cout <<"xxx_____xxx__xx__xxx____xxx__xxxxxx__xxxxxxxx_____xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx"<< endl;
              cout <<"xxx_____xxx__xx__xxx____xxx__xxxxxx___xxxxxx______xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx"<< endl;
              cout << endl << endl << endl;
              system("pause");
 
             cout <<"  You may use the ESC button to quit MINESWEEPER anytime you wish" << endl;
             cout <<"  The arrow buttons on your keyboard will be used to move your player around" << endl;
             cout <<"  The buttons < and > will be used to go up and down levels" << endl;
             cout <<"  The buttons = or - will be used to increse or decrease the size of your game" << endl;
             system("pause");
             cout << "  Enter the number of rows you would like to have" << endl;
             cin >> dX;
             while (dX > MAX_ROW) {
                  cout << " Please re-enter the number of rows you would like that is less than your previous entry" << endl;
                  cin >> dX;
             }
             while (dX < MIN_ROW) {
                  cout << " Please re-enter the number of rows you would like that is greater than your previous entry" << endl;
                  cin >> dX;
             }
             cout << " Enter the number of columns you would like to have" << endl;
             cin >> dY;
             while (dY > MAX_COL) {
                  cout << " Please re-enter the number of columns you would like that is less than your previous entry" << endl;
                  cin >> dY;
             }
             while (dY < MIN_COL) {
                  cout << " Please re-enter the number of columns you would like that is greater than your previous entry" << endl;
                  cin >> dY;
             }
             cout << " Enter the depth you would like to have" << endl;
             cin >> dZ;
             while (dZ > MAX_DEPTH) {
                  cout << " Please re-enter the depth you would like that is less than your previous entry" << endl;
                  cin >> dZ;
             }
             while (dZ < MIN_DEPTH) {
              cout << " Please re-enter the depth you would like that is greater than your previous entry" << endl;
              cin >> dZ;
             }
 
             GridActive myGridActive (dX, dY, dZ);
 
             do{
                   myGridActive.setActive ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ());
                   myGridActive.print (myGridActive.getZ());
                   myGridActive.printDimensions ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ() );
                   myGridActive.printDimensions ( myGridActive.getRow(), myGridActive.getCol(), myGridActive.getDepth() );
                   keyPressed = toascii ( getch() );
                   switch (keyPressed)
                   {
                        case 27 : quit = true; break;
                        case 44 : myGridActive.goDown (); break;
                        case 46 : myGridActive.goUp (); break;
                        case 61 : myGridActive.upsize (); break;
                        case 99 : system ("cls"); break;
                        case 45 : myGridActive.downsize (); break;
                        case 96 : {
                             keyPressed = toascii (getch() );
                             switch (keyPressed)
                             {
                                  case 72 : myGridActive.goNorth (); break;
                                  case 80 : myGridActive.goSouth (); break;
                                  case 75 : myGridActive.goWest (); break;
                                  case 77 : myGridActive.goEast (); break;
                                  default: break;
                             }
                             default: break:
                        }
                   }
              }
              while (!quit);
              cout << "\n Would you like to start over? Press any key \n  Would you like to quit? Press N ";
              keyPressed = getch ();
              quit = false;
              if (( keyPressed == 'N' ) || (keyPressed == 'n' ))
              quit = true;
         }
         cin.get(); // wait
         return 0;
         while (!quit);
     printEnd();
}

now i get the following errors

line 91 : error C2143: syntax error : missing ';' before '='
line 91 : error C2350: 'Room::Room::Room' is not a static member
line 91 : fatal error C1004: unexpected end of file found

line 91 is the Room::Room operator=(const Room &node) {

Room& Room (const Room &node) {
     bool visited = node.visited;
     bool active = node.active;
}

The above is incorrect. It should be like this

Room::Room (const Room &node) {

>>Room::Room operator=(const Room& node) {
The operator needs a return value, like this:

Room& Room::operator=(const Room& node) {

#include <iostream> //For console output
#include <windows.h>   // WinApi header
using namespace std;
 
#define EMPTY_CELL     177
#define CURSOR     1
#define TAIL     219
#define NUM     6
 
class Room {
 
public:
     bool visited;
     bool active;
     Room(); // Default Constructor
     Room(bool visited, bool active); // Overloaded Constructor
     Room(const Room &node); //  Copy Constructor
     Room& operator= (const Room& node); // Operator
     ~Room(); //  Destructor/Destroyer
 //Mutators
     void setActive (); // Gets the console ready to draw the minesweeper grid
     char draw (); // Draws the grid for minesweeper
};
Room::Room() {
     bool visited = NULL;
     bool active = NULL;
}
 
Room::Room(bool v, bool a) {
     visited = v;
     active = a;
}
 
Room::Room (const Room &node) {
     bool visited = node.visited;
     bool active = node.active;
}
 
Room& Room::operator=(const Room& node) {
     this->visited = node.visited;
     this->active = node.active;
     return *this;
}
 
void Room::setActive () {
     this->visited = true;
     this->active = true;
}
 
char Room::draw () {
     char ch = char (EMPTY_CELL);
     if (visited) {
     ch = char (TAIL);
     }
     if (this->active) {
          ch = char (CURSOR);
          this->active = false;
     }
     return ch;
}
 
Room::~Room () {
}
/************************************************************************************************/
 
#define MIN_COL  2  //minimum size allowed for number of columns
#define MIN_ROW 2  //minimum size allowed for number of rows
#define MIN_DEPTH 2  //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE     205
#define RIGHT_UPPER_CORNER     187
#define LEFT_LOWER_CORNER     200
#define RIGHT_LOWER_CORNER     188
#define INTERSECTION     206
#define VERTICAL_WITH_RIGHT_TURN     204
#define VERTICAL_WITH_LEFT_TURN     185
#define HORIZONTAL_WITH_DOWN_LINE     203
#define HORIZONTAL_WITH_UP_LINE     202
#define RROW 11;
#define RCOL 11;
#define EMPTY_CELL     177
#define CURSOR     1
#define TAIL     219
#define NUM     6
 
 
class Dynamic3DArray {
 
 
protected:
     int ROW;
     int COL;
     int DEPTH;
     Room** array;
public:
     Dynamic3DArray (); // Default Consturtor
     Dynamic3DArray (int row, int col, int depth); // Overloaded Constructor
     Dynamic3DArray (const Dynamic3DArray& dynamic3DArray); // Copy Constructor
     Dynamic3DArray& operator= (const Dynamic3DArray& dynamic3DArray); //Assignment Operator
     ~Dynamic3DArray (); //Destroyer/Destructor
//Accessors
     int getROW (); //Gets the number of rows
     int getCOL (); //Gets the number of columns
     int getDEPTH (); //Gets the number for the depth
//Mutators
     void create (); //Will create a 3Dimentional grid
     void destroy (); //Destroys the grid to free memory
     void setActive (int x, int y, int z); //Will make the cells visited
     bool setDimentions (); //Will set the dimentions of the grid
     void resize (int x, int y, int z); //Will change the dimentions of the grid
     void print (int depth); //This prints the grid with the depth given by user
     void printDimentions (int x, int y, int z); //This prints the overall grid
};
 
Dynamic3DArray::Dynamic3DArray () {
     this-> ROW = 0;
     this-> COL = 0;
     this-> DEPTH = 0;
     array = NULL;
}
 
void Dynamic3DArray::create () {
     array = new Room**[ROW];
     for (int r=0; r<ROW; r++); {
     array[r] = new Room*[COL];
     for (int c=0; c<COL; c++) 
     array[r][c] = new Room[DEPTH];
     }
}
 
void Dynamic3DArray::destroy () {
     for (int r=0; r<ROW; r++) {
     for (int c=0; c<COL; c++)
     delete [] array [r][c];
     delete [] array [r];
     }
     delete [] array;
}
 
Dynamic3DArray::Dynamic3DArray (int row, int col, int depth) {
     this-> ROW = row;
     this-> COL = col;
     this-> DEPTH = depth;
     create ();
}
 
Dynamic3DArray::Dynamic3DArray (const Dynamic3DArray& dynamic3DArray) {
     this-> ROW = dynamic3DArray.ROW;
     this-> COL = dynamic3DArray.COL;
     this-> DEPTH = dynamic3DArray.DEPTH;
     create ();
}
 
void Dynamic3DArray::setActive (int x, int y, int z) {
     this-> array [x-1][y-1][z-1].setActive ();
}
 
void Dynamic3DArray::printDimentions (int x, int y, int z) {
     cout << "   < " << x << "," << y << "," << z << ">" << endl << endl;
}
 
void Dynamic3DArray::resize (int r, int c, int d) {
     Dynamic3DArray temp (*this);
     temp = *this;
     this-> destroy ();
     this-> ROW = r;
     this-> COL = c;
     this-> DEPTH = d;
     this-> create ();
     if (temp.ROW<ROW) {
          for (int r=0; r<temp.ROW; r++) {
               for (int c=0; c<temp.COL; c++) {
                    for (int d=0; d<temp.DEPTH; d++)
                    this-> array[r+1][c+1][d+1]=temp.array[r][c][d];
               }
          }
     }
     else {
          for (int r=0; r<temp.ROW; r++) {
               for (int c=0; c<COL; c++) {
                    for (int d=0; d<DEPTH; d++) {
                         this->array[r][c][d]=temp.array[r+1][c+1][d+1];
                    }
               }
          }
     }
}
int Dynamic3DArray::getROW () {
     return this-> ROW;
}
int Dynamic3DArray::getCOL () {
     return this-> COL;
}
int Dynamic3DArray::getDEPTH () {
     return this->DEPTH;
}
Dynamic3DArray::~Dynamic3DArray () {
     destroy ();
}
Dynamic3DArray& Dynamic3DArray::operator=(const Dynamic3DArray& dynamic3DArray) {
 destroy ();
     this->ROW = dynamic3DArray.ROW;
     this->COL = dynamic3DArray.COL;
     this->DEPTH = dynamic3DArray.DEPTH;
     create ();
     for (int r=0; r<ROW; r++) {
          for (int c=0; c<COL; c++) {
               for (int d=0; d<DEPTH; d++)
              array[r][c][d]=dynamic3DArray.array[r][c][d];
          }
     }
     return *this;
}
void Dynamic3DArray::print (int depth) {
     system ("cls");
     cout << char (LEFT_UPPER_CORNER);
          for (int r=0; r<ROW; r++) {
          cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_DOWN_LINE);
          }
          cout << "\b" << char (RIGHT_UPPER_CORNER) << endl;
          for (int c=0; c<COL; c++) {
               cout << char (VERTICAL_LINE);
                    for (int r=0; r<ROW; r++) {
                         cout << array[r][c][depth-1].draw () << char (VERTICAL_LINE);
                    }
                    cout << "\b" << char (VERTICAL_WITH_RIGHT_TURN);
                    if (c< (COL-1)) {
                         for (int i=0; i<ROW; i++) {
                              cout << char (HORIZONTAL_LINE) << char (INTERSECTION);
                         }
                         cout << "\b" << char (VERTICAL_WITH_LEFT_TURN) << "\n";
                    }
                    else {
                         cout << "\b" << char (LEFT_LOWER_CORNER);
                         for (int r=0; r<ROW; r++) {
                              cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_UP_LINE);
                         }
                    }
               }
 cout << "\b" << char (RIGHT_LOWER_CORNER) << "\n";
}
 
/************************************************************************************************/
#define MIN_COL  2  //minimum size allowed for number of columns
#define MIN_ROW 2  //minimum size allowed for number of rows
#define MIN_DEPTH 2  //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE     205
#define RIGHT_UPPER_CORNER     187
#define LEFT_LOWER_CORNER     200
#define RIGHT_LOWER_CORNER     188
#define INTERSECTION     206
#define VERTICAL_WITH_RIGHT_TURN     204
#define VERTICAL_WITH_LEFT_TURN     185
#define HORIZONTAL_WITH_DOWN_LINE     203
#define HORIZONTAL_WITH_UP_LINE     202
#define RROW 11;
#define RCOL 11;
#define NUM     6
 
 
class GridActive:Dynamic3DArray {
private:
     int x;
     int y;
     int z;
public:
     GridActive::GridActive ():Dynamic3DArray ();
     GridActive (int R, int C, int D);
     GridActive (const GridActive & grid);
     ~GridActive ();
 
//Accessors
     bool goNorth ();
     bool goSouth ();
     bool goWest ();
     bool goEast ();
     bool goUp ();
     bool goDown ();
     int getRow ();
     int getCol ();
     int getDepth ();
     int getX ();
     int getY ();
     int getZ ();
//Mutators
     void upsize ();
     void downsize ();
     void setActive ();
     void printDimentions (int x, int y, int z);
     void print (int dep);
     void GridActive::setActive (int x, int y, int z);
};
GridActive::GridActive ():Dynamic3DArray () {
     x=0;
     y=0;
     z=0;
}
GridActive::GridActive (int R, int C, int D):Dynamic3DArray (R, C, D) {
     x=1;
     y=1;
     z=1;
}
 
GridActive::~GridActive () {
}
 
GridActive::GridActive (const GridActive & grid):Dynamic3DArray(grid) {
}
 
GridActive& GridActive::operator= (const GridActive & grid) {
     destroy ();
     this->x = grid.x;
     this->y = grid.y;
     this->z = grid.z;
     this->ROW = grid.ROW;
     this->COL = grid.COL;
     this->DEPTH = grid.DEPTH;
     create ();
     int*** array = new int**[DEPTH];
     for (int r=0; r<ROW; r++) {
           for (int c=0; c<COL; c++) {
                for (int d=0; d<DEPTH; d++)
                array[r][c][d] = grid.array[r][c][d];
           }
     }
     return *this;
}
 
bool GridActive::goNorth () {
     if (y == 1) return false;
     y--;
     return true;
}
 
bool GridActive::goSouth () {
     if (y == COL) return false;
     y++;
     return true;
}
 
bool GridActive::goDown () {
     if (z == 1) return false;
     z--;
     return true;
}
 
bool GridActive::goUp () {
     if (z == DEPTH) return false;
     z++;
     return true;
}
bool GridActive::goEast () {
     if (x == ROW) return false;
     x++;
     return true;
}
 
bool GridActive::goWest () {
     if (x == 1) return false;
     x--;
     return true;
}
int GridActive::getRow () {
     return ROW;
}
int GridActive::getCol () {
     return COL;
}
int GridActive::getDepth () {
     return DEPTH;
}
void GridActive::print (int dep) {
     Dynamic3DArray::print (dep);
}
int GridActive::getX () {
     return x;
}
int GridActive::getY () {
     return y;
}
int GridActive::getZ () {
     return z;
}
void GridActive::setActive (int x, int y, int z) {
     Dynamic3DArray::setActive (x, y, z);
}
void GridActive::printDimentions (int x, int y, int z) {
     Dynamic3DArray::printDimentions (x, y, z);
}
void GridActive::upsize() {
     if ((ROW< MAX_ROW-2) && (COL<MAX_COL-2) && (DEPTH< MAX_DEPTH-2)) {
          resize (this->ROW+2, this->COL+2, this->DEPTH+2);
          x++;
          y++;
          z++;
     }
}
void GridActive::downsize () {
     if (ROW > MIN_ROW && COL > MIN_COL && DEPTH > MIN_DEPTH &&
  this->x != this->y !=1 && this->z !=1 &&
  this->x != this->ROW && this->y != this->COL && this->z != DEPTH) {
          resize (this->ROW-2, this->COL-2, this->DEPTH-2);
          x--;
          y--;
          z--;
     }
}
 
 
void printEnd() {
     system ("cls");
     cout << "XXXXXXXXXXXXXXX  XX     XX      XXX      XXXXX      XXX  XXX     XXX     XXX      XXX    XXXXX         XXX     XXX" << endl;
     cout << "XXXXXXXXXXXXXXX  XX     XX     XXXXX     XXXXXX     XXX  XXX   XXX       XXX    XXX    XXX   XXX     XXX     XXX" << endl;
     cout << "      XXX       XX     XX    XXX XXX    XXX XXX    XXX  XXX  XXX        XXX  XXX    XXX       XXX XXX     XXX" << endl;
     cout << "      XXX       XXXXXXXXX   XXX   XXX   XXX  XXX   XXX  XXXXXXX        XXXXX     XXX           XXX XXX     XXX" << endl;
     cout << "      XXX       XXXXXXXXX   XXXXXXXXX   XXX   XXX  XXX  XXXXXXX        XXXX      XXX           XXX XXX     XXX" << endl;
     cout << "      XXX       XX     XX  XXXXXXXXXXX  XXX    XXX XXX  XXX   XXX        XXX         XXX        XXX   XXX     XXX" << endl;
     cout << "      XXX       XX     XX  XXX     XXX  XXX     XXXXXX  XXX    XXX    XXX           XXX   XXX      XXX   XXX " << endl;
     cout << "      XXX       XX     XX  XXX     XXX  XXX      XXXXX  XXX     XXX    XXX             XXXXX           XXXXXX  " << endl;
     cout << "                                                                                                                " << endl;
     cout << "XXXXXXXXXX     XXXXX       XXXXXXXX     XXXXXXXX    XX          X     XX     XXX XX XXX       XX       XXXXXXX  " << endl;
     cout << "XXXXXXXXXX   XXX   XXX     XXXXXXXXX     XXX   XXXX  XX         XXX    XX   XXX   XX XXXX      XX    XXXXX    XX " << endl;
     cout << "XXX     XXX       XXX   XXX    XXX      XXX      XX XX        XXXXX   XX XXX     XX XX XX     XX  XXXX          " << endl;
     cout << "XXXXXX   XXX           XXX XXX   XXX     XXX    XXX  XX       XX  XXX  XXXX      XX XX  XX    XX XXX            " << endl;
     cout << "XXXXXX   XXX           XXX XXXXXXXX     XXXXXXX     XX       XXXXXXX  XXX      XX XX   XX   XX XXX       XXXXX" << endl;
     cout << "XXX     XXX       XXX   XXX  XXX     XXX         XX     XXXXXXXXX XXX        XX XX    XX  XX  XXXX       XXX" << endl;
     cout << "XXX       XXX   XXX     XXX   XXX     XXX         XXXXXXX XX    XXX XXX        XX XX     XXXXX    XXXXXXXXXX  " << endl;
     cout << "XXX         XXXXX       XXX    XXX     XXX         XXXXXXX XX    XXX XXX        XX XX      XXXX       XXXXXX   " << endl;
}
 
void main () {
     HANDLE  hConsole;
     int k;
 
     hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
 
     for(k = 1; k < 2; k++) {
          SetConsoleTextAttribute(hConsole, 26);
          char keyPressed;
          bool quit = false;
          int dX;
          int dY;
          int dZ;
          do {
              system("cls");
              cout <<endl;
              cout <<endl;
              cout <<"xxxx___xxxx__xx__xxx____xxx__xxxxxx___xxxxxx___xxx___________xxx__xxxxxx__xxxxxx__xxxxx_____xxxxxx__xxxxxx" << endl;
              cout <<"xxxx___xxxx__xx__xxxx___xxx__xxxxxx__xxxxxxxx__xxx___________xxx__xxxxxx__xxxxxx__xxxxxxx___xxxxxx__xxxxxxx"<< endl;
              cout <<"xxxxx_xxxxx__xx__xxxx___xxx__xx______xxx__xxx__xxx___________xxx__xx______xx______xx___xxx__xx______xx___xx"<< endl;
              cout <<"xxx_xxx_xxx__xx__xxxxx__xxx__xx______xxx________xxx_________xxx___xx______xx______xx___xxx__xx______xx___xx"<< endl;
              cout <<"xxx_xxx_xxx__xx__xxx_xx_xxx__xxxxx____xxx_______xxx____x____xxx___xxxxx___xxxxx___xxxxxxx___xxxxx___xxxxxx"<< endl;
              cout <<"xxx__x__xxx__xx__xxx__xxxxx__xxxxx______xxx______xxx___x___xxx____xxxxx___xxxxx___xxx_______xxxxx___xxxx"<< endl;
              cout <<"xxx_____xxx__xx__xxx__xxxxx__xx___________xxx____xxx__xxx__xxx____xx______xx______xx________xx______xx_xx"<< endl;
              cout <<"xxx_____xxx__xx__xxx___xxxx__xx______xxx__xxx_____xxxx___xxxx_____xx______xx______xx________xx______xx__xx"<< endl;
              cout <<"xxx_____xxx__xx__xxx____xxx__xxxxxx__xxxxxxxx_____xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx"<< endl;
              cout <<"xxx_____xxx__xx__xxx____xxx__xxxxxx___xxxxxx______xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx"<< endl;
              cout << endl << endl << endl;
              system("pause");
 
             cout <<"  You may use the ESC button to quit MINESWEEPER anytime you wish" << endl;
             cout <<"  The arrow buttons on your keyboard will be used to move your player around" << endl;
             cout <<"  The buttons < and > will be used to go up and down levels" << endl;
             cout <<"  The buttons = or - will be used to increse or decrease the size of your game" << endl;
             system("pause");
             cout << "  Enter the number of rows you would like to have" << endl;
             cin >> dX;
             while (dX > MAX_ROW) {
                  cout << " Please re-enter the number of rows you would like that is less than your previous entry" << endl;
                  cin >> dX;
             }
             while (dX < MIN_ROW) {
                  cout << " Please re-enter the number of rows you would like that is greater than your previous entry" << endl;
                  cin >> dX;
             }
             cout << " Enter the number of columns you would like to have" << endl;
             cin >> dY;
             while (dY > MAX_COL) {
                  cout << " Please re-enter the number of columns you would like that is less than your previous entry" << endl;
                  cin >> dY;
             }
             while (dY < MIN_COL) {
                  cout << " Please re-enter the number of columns you would like that is greater than your previous entry" << endl;
                  cin >> dY;
             }
             cout << " Enter the depth you would like to have" << endl;
             cin >> dZ;
             while (dZ > MAX_DEPTH) {
                  cout << " Please re-enter the depth you would like that is less than your previous entry" << endl;
                  cin >> dZ;
             }
             while (dZ < MIN_DEPTH) {
              cout << " Please re-enter the depth you would like that is greater than your previous entry" << endl;
              cin >> dZ;
             }
 
             GridActive myGridActive (dX, dY, dZ);
 
             do{
                   myGridActive.setActive ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ());
                   myGridActive.print (myGridActive.getZ());
                   myGridActive.printDimensions ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ() );
                   myGridActive.printDimensions ( myGridActive.getRow(), myGridActive.getCol(), myGridActive.getDepth() );
                   keyPressed = toascii ( getch() );
                   switch (keyPressed)
                   {
                        case 27 : quit = true; break;
                        case 44 : myGridActive.goDown (); break;
                        case 46 : myGridActive.goUp (); break;
                        case 61 : myGridActive.upsize (); break;
                        case 99 : system ("cls"); break;
                        case 45 : myGridActive.downsize (); break;
                        case 96 : {
                             keyPressed = toascii (getch() );
                             switch (keyPressed)
                             {
                                  case 72 : myGridActive.goNorth (); break;
                                  case 80 : myGridActive.goSouth (); break;
                                  case 75 : myGridActive.goWest (); break;
                                  case 77 : myGridActive.goEast (); break;
                                  default: break;
                             }
                             default: break:
                        }
                   }
              }
              while (!quit);
              cout << "\n Would you like to start over? Press any key \n  Would you like to quit? Press N ";
              keyPressed = getch ();
              quit = false;
              if (( keyPressed == 'N' ) || (keyPressed == 'n' ))
              quit = true;
         }
         cin.get(); // wait
         return 0;
         while (!quit);
     printEnd();
}

now these errors come up

line 187 : error C2440: '=' : cannot convert from 'class Room *** ' to 'class Room ** ' Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast

line 189 : error C2440: '=' : cannot convert from 'class Room ** ' to 'class Room *' Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast

line 191 : error C2679: binary '=' : no operator defined which takes a right-hand operand of type 'class Room *' (or there is no acceptable conversion)

line 199 : error C2440: 'delete' : cannot convert from 'class Room' to ''
No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called

line 199 : fatal error C1903: unable to recover from previous error(s); stopping compilation

this is line 186 void Dynamic3DArray::create () {
line 187 array = new Room**[ROW];
line 188 for (int r=0; r<ROW; r++); {
line 189 array[r] = new Room*[COL];
line 190 for (int c=0; c<COL; c++)
line 191 array[r][c] = new Room[DEPTH];
line 192 }
line 193 }

this is line 199 delete [] array [r][c];

which class is this??? its quite a big program

Still got a few errors; I've commented them in:

void Dynamic3DArray::create () {
     array = new Room**[ROW]; // you only need one * here, remember that new automatically creates a pointer
     for (int r=0; r<ROW; r++); { // remove semicolon here
         array[r] = new *Room[COL]; // remove *, same as before
         for (int c=0; c<COL; c++) 
            array[r][c] = new Room[DEPTH]; // not sure what you're trying to do here
     }
}

The line I highlighted I'm confused about what you were trying to do. Are you trying to make a 2-dimensional array? If so, then why not allocate that in the first new statement.

I'm similarly confused about this function:

void Dynamic3DArray::destroy () {
     for (int r=0; r<ROW; r++) {
     for (int c=0; c<COL; c++)
     delete [] array [r][c];
     delete [] array [r];
     }
     delete [] array;
}

By referencing your array like that, you aren't providing a pointer that delete can deallocate. You could use the dereference symbol (&) to make the error go away, but I don't see what you're trying to do.

#include <iostream> //For console output
#include <windows.h> // WinApi header
#include <conio.h>
using namespace std;
 
#define EMPTY_CELL 177
#define CURSOR 1
#define TAIL 219
#define NUM 6
 
class Room {
private:
 
public:
bool visited;
bool active;
Room(); // Default Constructor
Room(bool visited, bool active); // Overloaded Constructor
Room(const Room &node); // Copy Constructor
Room& operator= (const Room& node); // Operator
~Room(); // Destructor/Destroyer
//Mutators
void setActive (); // Gets the console ready to draw the minesweeper grid
char draw (); // Draws the grid for minesweeper
};
Room::Room() {
bool visited = NULL;
bool active = NULL;
}
 
Room::Room(bool v, bool a) {
visited = v;
active = a;
}
 
Room::Room (const Room &node) {
bool visited = node.visited;
bool active = node.active;
}
 
Room& Room::operator=(const Room& node) {
this->visited = node.visited;
this->active = node.active;
return *this;
}
 
void Room::setActive () {
this->visited = true;
this->active = true;
}
 
char Room::draw () {
char ch = char (EMPTY_CELL);
if (visited) {
ch = char (TAIL);
}
if (this->active) {
ch = char (CURSOR);
this->active = false;
}
return ch;
}
 
Room::~Room () {
}
/************************************************************************************************/
 
#define MIN_COL 2 //minimum size allowed for number of columns
#define MIN_ROW 2 //minimum size allowed for number of rows
#define MIN_DEPTH 2 //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE 205
#define RIGHT_UPPER_CORNER 187
#define LEFT_LOWER_CORNER 200
#define RIGHT_LOWER_CORNER 188
#define INTERSECTION 206
#define VERTICAL_WITH_RIGHT_TURN 204
#define VERTICAL_WITH_LEFT_TURN 185
#define HORIZONTAL_WITH_DOWN_LINE 203
#define HORIZONTAL_WITH_UP_LINE 202
#define RROW 11;
#define RCOL 11;
#define EMPTY_CELL 177
#define CURSOR 1
#define TAIL 219
#define NUM 6
class Dynamic3DArray {
protected:
int ROW;
int COL;
int DEPTH;
Room*** array;
public:
Dynamic3DArray (); // Default Consturtor
Dynamic3DArray (int row, int col, int depth); // Overloaded Constructor
Dynamic3DArray (const Dynamic3DArray& dynamic3DArray); // Copy Constructor
Dynamic3DArray& operator= (const Dynamic3DArray& dynamic3DArray); //Assignment Operator
~Dynamic3DArray (); //Destroyer/Destructor
//Accessors
int getROW (); //Gets the number of rows
int getCOL (); //Gets the number of columns
int getDEPTH (); //Gets the number for the depth
//Mutators
void create (); //Will create a 3Dimentional grid
void destroy (); //Destroys the grid to free memory
void setActive (int x, int y, int z); //Will make the cells visited
bool setDimentions (); //Will set the dimentions of the grid
void resize (int x, int y, int z); //Will change the dimentions of the grid
void print (int depth); //This prints the grid with the depth given by user
void printDimensions (int x, int y, int z); //This prints the overall grid
};
Dynamic3DArray::Dynamic3DArray () {
this-> ROW = 0;
this-> COL = 0;
this-> DEPTH = 0;
array = NULL;
}
 
void Dynamic3DArray::create () {
array = new Room** [ROW];
for (int r=0; r<ROW; r++) {
array[r] = new Room* [COL];
for (int c=0; c<COL; c++) 
array[r][c] = new Room [DEPTH];
}
}
 
void Dynamic3DArray::destroy () {
for (int r=0; r<ROW; r++) {
for (int c=0; c<COL; c++)
delete [] array [r][c];
delete [] array [r];
}
delete [] array;
}
 
Dynamic3DArray::Dynamic3DArray (int row, int col, int depth) {
this-> ROW = row;
this-> COL = col;
this-> DEPTH = depth;
create ();
}
 
Dynamic3DArray::Dynamic3DArray (const Dynamic3DArray& dynamic3DArray) {
this-> ROW = dynamic3DArray.ROW;
this-> COL = dynamic3DArray.COL;
this-> DEPTH = dynamic3DArray.DEPTH;
create ();
}
 
void Dynamic3DArray::setActive (int x, int y, int z) {
this-> array [x-1][y-1][z-1].setActive ();
}
 
void Dynamic3DArray::printDimensions (int x, int y, int z) {
cout << " < " << x << "," << y << "," << z << ">" << endl << endl;
}
 
void Dynamic3DArray::resize (int r, int c, int d) {
Dynamic3DArray temp (*this);
temp = *this;
this-> destroy ();
this-> ROW = r;
this-> COL = c;
this-> DEPTH = d;
this-> create ();
if (temp.ROW<ROW) {
for (int r=0; r<temp.ROW; r++) {
for (int c=0; c<temp.COL; c++) {
for (int d=0; d<temp.DEPTH; d++)
this-> array[r+1][c+1][d+1]=temp.array[r][c][d];
}
}
}
else {
for (int r=0; r<temp.ROW; r++) {
for (int c=0; c<COL; c++) {
for (int d=0; d<DEPTH; d++) {
this->array[r][c][d]=temp.array[r+1][c+1][d+1];
}
}
}
}
}
int Dynamic3DArray::getROW () {
return this-> ROW;
}
int Dynamic3DArray::getCOL () {
return this-> COL;
}
int Dynamic3DArray::getDEPTH () {
return this->DEPTH;
}
Dynamic3DArray::~Dynamic3DArray () {
destroy ();
}
Dynamic3DArray& Dynamic3DArray::operator=(const Dynamic3DArray& dynamic3DArray) {
destroy ();
this->ROW = dynamic3DArray.ROW;
this->COL = dynamic3DArray.COL;
this->DEPTH = dynamic3DArray.DEPTH;
create ();
for (int r=0; r<ROW; r++) {
for (int c=0; c<COL; c++) {
for (int d=0; d<DEPTH; d++)
array[r][c][d]=dynamic3DArray.array[r][c][d];
}
}
return *this;
}
void Dynamic3DArray::print (int depth) {
system ("cls");
cout << char (LEFT_UPPER_CORNER);
for (int r=0; r<ROW; r++) {
cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_DOWN_LINE);
}
cout << "\b" << char (RIGHT_UPPER_CORNER) << endl;
for (int c=0; c<COL; c++) {
cout << char (VERTICAL_LINE);
for (int r=0; r<ROW; r++) {
cout << array[r][c][depth-1].draw () << char (VERTICAL_LINE);
}
cout << "\b" << char (VERTICAL_WITH_RIGHT_TURN);
if (c< (COL-1)) {
for (int i=0; i<ROW; i++) {
cout << char (HORIZONTAL_LINE) << char (INTERSECTION);
}
cout << "\b" << char (VERTICAL_WITH_LEFT_TURN) << "\n";
}
else {
cout << "\b" << char (LEFT_LOWER_CORNER);
for (int r=0; r<ROW; r++) {
cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_UP_LINE);
}
}
}
cout << "\b" << char (RIGHT_LOWER_CORNER) << "\n";
}
 
/************************************************************************************************/
#define MIN_COL 2 //minimum size allowed for number of columns
#define MIN_ROW 2 //minimum size allowed for number of rows
#define MIN_DEPTH 2 //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE 205
#define RIGHT_UPPER_CORNER 187
#define LEFT_LOWER_CORNER 200
#define RIGHT_LOWER_CORNER 188
#define INTERSECTION 206
#define VERTICAL_WITH_RIGHT_TURN 204
#define VERTICAL_WITH_LEFT_TURN 185
#define HORIZONTAL_WITH_DOWN_LINE 203
#define HORIZONTAL_WITH_UP_LINE 202
#define RROW 11;
#define RCOL 11;
#define NUM 6
class GridActive:Dynamic3DArray {
private:
int x;
int y;
int z;
public:
GridActive ();
GridActive (int R, int C, int D);
GridActive (const GridActive & grid);
~GridActive ();
GridActive& GridActive::operator= (const GridActive & grid);
 
//Accessors
bool goNorth ();
bool goSouth ();
bool goWest ();
bool goEast ();
bool goUp ();
bool goDown ();
int getRow ();
int getCol ();
int getDepth ();
int getX ();
int getY ();
int getZ ();
//Mutators
void upsize ();
void downsize ();
void setActive ();
void printDimensions (int x, int y, int z);
void print (int dep);
void GridActive::setActive (int x, int y, int z);
};
GridActive::GridActive ():Dynamic3DArray () {
x=0;
y=0;
z=0;
}
GridActive::GridActive (int R, int C, int D):Dynamic3DArray (R, C, D) {
x=1;
y=1;
z=1;
}
GridActive::~GridActive () {
}
GridActive::GridActive (const GridActive & grid):Dynamic3DArray(grid) {
}
GridActive& GridActive::operator= (const GridActive & grid) {
destroy ();
this->x = grid.x;
this->y = grid.y;
this->z = grid.z;
this->ROW = grid.ROW;
this->COL = grid.COL;
this->DEPTH = grid.DEPTH;
create ();
for (int r=0; r<ROW; r++) {
for (int c=0; c<COL; c++) {
for (int d=0; d<DEPTH; d++)
array[r][c][d] = grid.array[r][c][d];
}
}
return *this;
}
bool GridActive::goNorth () {
if (y == 1) return false;
y--;
return true;
}
bool GridActive::goSouth () {
if (y == COL) return false;
y++;
return true;
}
bool GridActive::goDown () {
if (z == 1) return false;
z--;
return true;
}
bool GridActive::goUp () {
if (z == DEPTH) return false;
z++;
return true;
}
bool GridActive::goEast () {
if (x == ROW) return false;
x++;
return true;
}
bool GridActive::goWest () {
if (x == 1) return false;
x--;
return true;
}
int GridActive::getRow () {
return ROW;
}
int GridActive::getCol () {
return COL;
}
int GridActive::getDepth () {
return DEPTH;
}
void GridActive::print (int dep) {
Dynamic3DArray::print (dep);
}
int GridActive::getX () {
return x;
}
int GridActive::getY () {
return y;
}
int GridActive::getZ () {
return z;
}
void GridActive::setActive (int x, int y, int z) {
Dynamic3DArray::setActive (x, y, z);
}
void GridActive::printDimensions (int x, int y, int z) {
Dynamic3DArray::printDimensions (x, y, z);
}
void GridActive::upsize() {
if ((ROW< MAX_ROW-2) && (COL<MAX_COL-2) && (DEPTH< MAX_DEPTH-2)) {
resize (this->ROW+2, this->COL+2, this->DEPTH+2);
x++;
y++;
z++;
}
}
void GridActive::downsize () {
if (ROW > MIN_ROW && COL > MIN_COL && DEPTH > MIN_DEPTH &&
this->x != this->y !=1 && this->z !=1 &&
this->x != this->ROW && this->y != this->COL && this->z != DEPTH) {
resize (this->ROW-2, this->COL-2, this->DEPTH-2);
x--;
y--;
z--;
}
}
 
 
void printEnd() {
system ("cls");
cout << "XXXXXXXXXXXXXXX XX XX XXX XXXXX XXX XXX XXX XXX XXX XXXXX XXX XXX" << endl;
cout << "XXXXXXXXXXXXXXX XX XX XXXXX XXXXXX XXX XXX XXX XXX XXX XXX XXX XXX XXX" << endl;
cout << " XXX XX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX" << endl;
cout << " XXX XXXXXXXXX XXX XXX XXX XXX XXX XXXXXXX XXXXX XXX XXX XXX XXX" << endl;
cout << " XXX XXXXXXXXX XXXXXXXXX XXX XXX XXX XXXXXXX XXXX XXX XXX XXX XXX" << endl;
cout << " XXX XX XX XXXXXXXXXXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX" << endl;
cout << " XXX XX XX XXX XXX XXX XXXXXX XXX XXX XXX XXX XXX XXX XXX " << endl;
cout << " XXX XX XX XXX XXX XXX XXXXX XXX XXX XXX XXXXX XXXXXX " << endl;
cout << " " << endl;
cout << "XXXXXXXXXX XXXXX XXXXXXXX XXXXXXXX XX X XX XXX XX XXX XX XXXXXXX " << endl;
cout << "XXXXXXXXXX XXX XXX XXXXXXXXX XXX XXXX XX XXX XX XXX XX XXXX XX XXXXX XX " << endl;
cout << "XXX XXX XXX XXX XXX XXX XX XX XXXXX XX XXX XX XX XX XX XXXX " << endl;
cout << "XXXXXX XXX XXX XXX XXX XXX XXX XX XX XXX XXXX XX XX XX XX XXX " << endl;
cout << "XXXXXX XXX XXX XXXXXXXX XXXXXXX XX XXXXXXX XXX XX XX XX XX XXX XXXXX" << endl;
cout << "XXX XXX XXX XXX XXX XXX XX XXXXXXXXX XXX XX XX XX XX XXXX XXX" << endl;
cout << "XXX XXX XXX XXX XXX XXX XXXXXXX XX XXX XXX XX XX XXXXX XXXXXXXXXX " << endl;
cout << "XXX XXXXX XXX XXX XXX XXXXXXX XX XXX XXX XX XX XXXX XXXXXX " << endl;
}
 
void main () {
HANDLE hConsole;
int k;
 
hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
 
for(k = 1; k < 2; k++) {
SetConsoleTextAttribute(hConsole, 26);
char keyPressed;
bool quit = false;
int dX;
int dY;
int dZ;
do {
system("cls");
cout <<endl;
cout <<endl;
cout <<"__xxxx___xxxx__xx__xxx____xxx__xxxxxx___xxxxxx___xxx___________xxx__xxxxxx__xxxxxx__xxxxx_____xxxxxx__xxxxxx__" << endl;
cout <<"__xxxx___xxxx__xx__xxxx___xxx__xxxxxx__xxxxxxxx__xxx___________xxx__xxxxxx__xxxxxx__xxxxxxx___xxxxxx__xxxxxxx_"<< endl;
cout <<"__xxxxx_xxxxx__xx__xxxx___xxx__xx______xxx__xxx__xxx___________xxx__xx______xx______xx___xxx__xx______xx___xx_"<< endl;
cout <<"__xxx_xxx_xxx__xx__xxxxx__xxx__xx______xxx________xxx_________xxx___xx______xx______xx___xxx__xx______xx___xx_"<< endl;
cout <<"__xxx_xxx_xxx__xx__xxx_xx_xxx__xxxxx____xxx_______xxx____x____xxx___xxxxx___xxxxx___xxxxxxx___xxxxx___xxxxxx__"<< endl;
cout <<"__xxx__x__xxx__xx__xxx__xxxxx__xxxxx______xxx______xxx___x___xxx____xxxxx___xxxxx___xxx_______xxxxx___xxxx____"<< endl;
cout <<"__xxx_____xxx__xx__xxx__xxxxx__xx___________xxx____xxx__xxx__xxx____xx______xx______xx________xx______xx_xx___"<< endl;
cout <<"__xxx_____xxx__xx__xxx___xxxx__xx______xxx__xxx_____xxxx___xxxx_____xx______xx______xx________xx______xx__xx__"<< endl;
cout <<"__xxx_____xxx__xx__xxx____xxx__xxxxxx__xxxxxxxx_____xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx__"<< endl;
cout <<"__xxx_____xxx__xx__xxx____xxx__xxxxxx___xxxxxx______xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx__"<< endl;
cout << endl;
cout << endl;
cout << endl;
system("pause");
 
cout <<" You may use the ESC button to quit MINESWEEPER anytime you wish" << endl;
cout <<" The arrow buttons on your keyboard will be used to move your player around" << endl;
cout <<" The buttons < and > will be used to go up and down levels" << endl;
cout <<" The buttons = or - will be used to increse or decrease the size of your game" << endl;
system("pause");
cout << " Enter the number of rows you would like to have" << endl;
cin >> dX;
while (dX > MAX_ROW) {
cout << " Please re-enter the number of rows you would like that is less than your previous entry" << endl;
cin >> dX;
}
while (dX < MIN_ROW) {
cout << " Please re-enter the number of rows you would like that is greater than your previous entry" << endl;
cin >> dX;
}
cout << " Enter the number of columns you would like to have" << endl;
cin >> dY;
while (dY > MAX_COL) {
cout << " Please re-enter the number of columns you would like that is less than your previous entry" << endl;
cin >> dY;
}
while (dY < MIN_COL) {
cout << " Please re-enter the number of columns you would like that is greater than your previous entry" << endl;
cin >> dY;
}
cout << " Enter the depth you would like to have" << endl;
cin >> dZ;
while (dZ > MAX_DEPTH) {
cout << " Please re-enter the depth you would like that is less than your previous entry" << endl;
cin >> dZ;
}
while (dZ < MIN_DEPTH) {
cout << " Please re-enter the depth you would like that is greater than your previous entry" << endl;
cin >> dZ;
}
 
GridActive myGridActive (dX, dY, dZ);
 
do{
myGridActive.setActive ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ() );
myGridActive.print ( myGridActive.getZ() );
myGridActive.printDimensions ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ() );
myGridActive.printDimensions ( myGridActive.getRow(), myGridActive.getCol(), myGridActive.getDepth() );
keyPressed = toascii ( getch() );
switch (keyPressed) {
case 1:
quit = true;
break;
case 2:
myGridActive.goDown ();
break;
case 3:
myGridActive.goUp ();
break;
case 4:
myGridActive.upsize ();
break;
case 5:
system ("cls");
break;
case 6:
myGridActive.downsize ();
break;
case 7: {
keyPressed = toascii (getch() );
switch (keyPressed) {
case 8:
myGridActive.goNorth ();
break;
case 9:
myGridActive.goSouth ();
break;
case 10:
myGridActive.goWest ();
break;
case 11:
myGridActive.goEast ();
break;
default: break;
}
default: break;
}
}
}
while (!quit);
cout << "\n Would you like to start over? Press any key \n Would you like to quit? Press N ";
keyPressed = getch ();
quit = false;
if (( keyPressed == 'N' ) || (keyPressed == 'n' ))
quit = true;
 
cin.get();
return;
printEnd();
}

now i have one error

Error:

line 663 : fatal error: unexpected end of file found

That probably means you've forgotten either a semicolon at the end of a class definition, or a closing brace from some function. Look through your file carefully.

Some points:

• You are missing two closing braces at the end of the program.

• In your class definition remove the class names before the functions since they are only needed when you provide function body to your functions outside the class.

GridActive& GridActive::operator= (const GridActive & grid);
// more code
void GridActive::setActive (int x, int y, int z);

• You need to provide a while statement after the third closing brace to make your do while statement work properly.

• Next time you undertake a project, do remember to text your code incrementally and not try to do in one go...

Here is updated running (correctly?) code devoid of errors (but not tested) :

#include <iostream> //For console output
#include <windows.h> // WinApi header
#include <conio.h>
using namespace std;

#define EMPTY_CELL 177
#define CURSOR 1
#define TAIL 219
#define NUM 6

class Room
{
private:

public:
    bool visited;
    bool active;
    Room(); // Default Constructor
    Room(bool visited, bool active); // Overloaded Constructor
    Room(const Room &node); // Copy Constructor
    Room& operator= (const Room& node); // Operator
    ~Room(); // Destructor/Destroyer
    //Mutators
    void setActive (); // Gets the console ready to draw the minesweeper grid
    char draw (); // Draws the grid for minesweeper
};
Room::Room()
{
    bool visited = NULL;
    bool active = NULL;
}

Room::Room(bool v, bool a)
{
    visited = v;
    active = a;
}

Room::Room (const Room &node)
{
    bool visited = node.visited;
    bool active = node.active;
}

Room& Room::operator=(const Room& node)
{
    this->visited = node.visited;
    this->active = node.active;
    return *this;
}

void Room::setActive ()
{
    this->visited = true;
    this->active = true;
}

char Room::draw ()
{
    char ch = char (EMPTY_CELL);
    if (visited)
    {
        ch = char (TAIL);
    }
    if (this->active)
    {
        ch = char (CURSOR);
        this->active = false;
    }
    return ch;
}

Room::~Room ()
{}
/************************************************************************************************/

#define MIN_COL 2 //minimum size allowed for number of columns
#define MIN_ROW 2 //minimum size allowed for number of rows
#define MIN_DEPTH 2 //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE 205
#define RIGHT_UPPER_CORNER 187
#define LEFT_LOWER_CORNER 200
#define RIGHT_LOWER_CORNER 188
#define INTERSECTION 206
#define VERTICAL_WITH_RIGHT_TURN 204
#define VERTICAL_WITH_LEFT_TURN 185
#define HORIZONTAL_WITH_DOWN_LINE 203
#define HORIZONTAL_WITH_UP_LINE 202
#define RROW 11;
#define RCOL 11;
#define EMPTY_CELL 177
#define CURSOR 1
#define TAIL 219
#define NUM 6
class Dynamic3DArray
{
protected:
    int ROW;
    int COL;
    int DEPTH;
    Room*** array;
public:
    Dynamic3DArray (); // Default Consturtor
    Dynamic3DArray (int row, int col, int depth); // Overloaded Constructor
    Dynamic3DArray (const Dynamic3DArray& dynamic3DArray); // Copy Constructor
    Dynamic3DArray& operator= (const Dynamic3DArray& dynamic3DArray); //Assignment Operator
    ~Dynamic3DArray (); //Destroyer/Destructor
    //Accessors
    int getROW (); //Gets the number of rows
    int getCOL (); //Gets the number of columns
    int getDEPTH (); //Gets the number for the depth
    //Mutators
    void create (); //Will create a 3Dimentional grid
    void destroy (); //Destroys the grid to free memory
    void setActive (int x, int y, int z); //Will make the cells visited
    bool setDimentions (); //Will set the dimentions of the grid
    void resize (int x, int y, int z); //Will change the dimentions of the grid
    void print (int depth); //This prints the grid with the depth given by user
    void printDimensions (int x, int y, int z); //This prints the overall grid
};
Dynamic3DArray::Dynamic3DArray ()
{
    this-> ROW = 0;
    this-> COL = 0;
    this-> DEPTH = 0;
    array = NULL;
}

void Dynamic3DArray::create ()
{
    array = new Room** [ROW];
    for (int r=0; r<ROW; r++)
    {
        array[r] = new Room* [COL];
        for (int c=0; c<COL; c++)
            array[r][c] = new Room [DEPTH];
    }
}

void Dynamic3DArray::destroy ()
{
    for (int r=0; r<ROW; r++)
    {
        for (int c=0; c<COL; c++)
            delete [] array [r][c];
        delete [] array [r];
    }
    delete [] array;
}

Dynamic3DArray::Dynamic3DArray (int row, int col, int depth)
{
    this-> ROW = row;
    this-> COL = col;
    this-> DEPTH = depth;
    create ();
}

Dynamic3DArray::Dynamic3DArray (const Dynamic3DArray& dynamic3DArray)
{
    this-> ROW = dynamic3DArray.ROW;
    this-> COL = dynamic3DArray.COL;
    this-> DEPTH = dynamic3DArray.DEPTH;
    create ();
}

void Dynamic3DArray::setActive (int x, int y, int z)
{
    this-> array [x-1][y-1][z-1].setActive ();
}

void Dynamic3DArray::printDimensions (int x, int y, int z)
{
    cout << " < " << x << "," << y << "," << z << ">" << endl << endl;
}

void Dynamic3DArray::resize (int r, int c, int d)
{
    Dynamic3DArray temp (*this);
    temp = *this;
    this-> destroy ();
    this-> ROW = r;
    this-> COL = c;
    this-> DEPTH = d;
    this-> create ();
    if (temp.ROW<ROW)
    {
        for (int r=0; r<temp.ROW; r++)
        {
            for (int c=0; c<temp.COL; c++)
            {
                for (int d=0; d<temp.DEPTH; d++)
                    this-> array[r+1][c+1][d+1]=temp.array[r][c][d];
            }
        }
    }
    else
    {
        for (int r=0; r<temp.ROW; r++)
        {
            for (int c=0; c<COL; c++)
            {
                for (int d=0; d<DEPTH; d++)
                {
                    this->array[r][c][d]=temp.array[r+1][c+1][d+1];
                }
            }
        }
    }
}
int Dynamic3DArray::getROW ()
{
    return this-> ROW;
}
int Dynamic3DArray::getCOL ()
{
    return this-> COL;
}
int Dynamic3DArray::getDEPTH ()
{
    return this->DEPTH;
}
Dynamic3DArray::~Dynamic3DArray ()
{
    destroy ();
}
Dynamic3DArray& Dynamic3DArray::operator=(const Dynamic3DArray& dynamic3DArray)
{
    destroy ();
    this->ROW = dynamic3DArray.ROW;
    this->COL = dynamic3DArray.COL;
    this->DEPTH = dynamic3DArray.DEPTH;
    create ();
    for (int r=0; r<ROW; r++)
    {
        for (int c=0; c<COL; c++)
        {
            for (int d=0; d<DEPTH; d++)
                array[r][c][d]=dynamic3DArray.array[r][c][d];
        }
    }
    return *this;
}
void Dynamic3DArray::print (int depth)
{
    system ("cls");
    cout << char (LEFT_UPPER_CORNER);
    for (int r=0; r<ROW; r++)
    {
        cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_DOWN_LINE);
    }
    cout << "\b" << char (RIGHT_UPPER_CORNER) << endl;
    for (int c=0; c<COL; c++)
    {
        cout << char (VERTICAL_LINE);
        for (int r=0; r<ROW; r++)
        {
            cout << array[r][c][depth-1].draw () << char (VERTICAL_LINE);
        }
        cout << "\b" << char (VERTICAL_WITH_RIGHT_TURN);
        if (c< (COL-1))
        {
            for (int i=0; i<ROW; i++)
            {
                cout << char (HORIZONTAL_LINE) << char (INTERSECTION);
            }
            cout << "\b" << char (VERTICAL_WITH_LEFT_TURN) << "\n";
        }
        else
        {
            cout << "\b" << char (LEFT_LOWER_CORNER);
            for (int r=0; r<ROW; r++)
            {
                cout << char (HORIZONTAL_LINE) << char (HORIZONTAL_WITH_UP_LINE);
            }
        }
    }
    cout << "\b" << char (RIGHT_LOWER_CORNER) << "\n";
}

/************************************************************************************************/
#define MIN_COL 2 //minimum size allowed for number of columns
#define MIN_ROW 2 //minimum size allowed for number of rows
#define MIN_DEPTH 2 //minimum size allowed for the depth
#define MAX_COL 12 //maximum size allowed for number of columns
#define MAX_ROW 12 //maximum size allowed for number of rows
#define MAX_DEPTH 12 //maximum size allowed for the depth
#define LEFT_UPPER_CORNER 201
#define VERTICAL_LINE 186
#define HORIZONTAL_LINE 205
#define RIGHT_UPPER_CORNER 187
#define LEFT_LOWER_CORNER 200
#define RIGHT_LOWER_CORNER 188
#define INTERSECTION 206
#define VERTICAL_WITH_RIGHT_TURN 204
#define VERTICAL_WITH_LEFT_TURN 185
#define HORIZONTAL_WITH_DOWN_LINE 203
#define HORIZONTAL_WITH_UP_LINE 202
#define RROW 11;
#define RCOL 11;
#define NUM 6
class GridActive:Dynamic3DArray
{
private:
    int x;
    int y;
    int z;
public:
    GridActive ();
    GridActive (int R, int C, int D);
    GridActive (const GridActive & grid);
    ~GridActive ();
    GridActive& operator= (const GridActive & grid);

    //Accessors
    bool goNorth ();
    bool goSouth ();
    bool goWest ();
    bool goEast ();
    bool goUp ();
    bool goDown ();
    int getRow ();
    int getCol ();
    int getDepth ();
    int getX ();
    int getY ();
    int getZ ();
    //Mutators
    void upsize ();
    void downsize ();
    void setActive ();
    void printDimensions (int x, int y, int z);
    void print (int dep);
    void setActive (int x, int y, int z);
};
GridActive::GridActive ():Dynamic3DArray ()
{
    x=0;
    y=0;
    z=0;
}
GridActive::GridActive (int R, int C, int D):Dynamic3DArray (R, C, D)
{
    x=1;
    y=1;
    z=1;
}
GridActive::~GridActive ()
{}
GridActive::GridActive (const GridActive & grid):Dynamic3DArray(grid)
{}
GridActive& GridActive::operator= (const GridActive & grid)
{
    destroy ();
    this->x = grid.x;
    this->y = grid.y;
    this->z = grid.z;
    this->ROW = grid.ROW;
    this->COL = grid.COL;
    this->DEPTH = grid.DEPTH;
    create ();
    for (int r=0; r<ROW; r++)
    {
        for (int c=0; c<COL; c++)
        {
            for (int d=0; d<DEPTH; d++)
                array[r][c][d] = grid.array[r][c][d];
        }
    }
    return *this;
}
bool GridActive::goNorth ()
{
    if (y == 1)
        return false;
    y--;
    return true;
}
bool GridActive::goSouth ()
{
    if (y == COL)
        return false;
    y++;
    return true;
}
bool GridActive::goDown ()
{
    if (z == 1)
        return false;
    z--;
    return true;
}
bool GridActive::goUp ()
{
    if (z == DEPTH)
        return false;
    z++;
    return true;
}
bool GridActive::goEast ()
{
    if (x == ROW)
        return false;
    x++;
    return true;
}
bool GridActive::goWest ()
{
    if (x == 1)
        return false;
    x--;
    return true;
}
int GridActive::getRow ()
{
    return ROW;
}
int GridActive::getCol ()
{
    return COL;
}
int GridActive::getDepth ()
{
    return DEPTH;
}
void GridActive::print (int dep)
{
    Dynamic3DArray::print (dep);
}
int GridActive::getX ()
{
    return x;
}
int GridActive::getY ()
{
    return y;
}
int GridActive::getZ ()
{
    return z;
}
void GridActive::setActive (int x, int y, int z)
{
    Dynamic3DArray::setActive (x, y, z);
}
void GridActive::printDimensions (int x, int y, int z)
{
    Dynamic3DArray::printDimensions (x, y, z);
}
void GridActive::upsize()
{
    if ((ROW< MAX_ROW-2) && (COL<MAX_COL-2) && (DEPTH< MAX_DEPTH-2))
    {
        resize (this->ROW+2, this->COL+2, this->DEPTH+2);
        x++;
        y++;
        z++;
    }
}
void GridActive::downsize ()
{
    if (ROW > MIN_ROW && COL > MIN_COL && DEPTH > MIN_DEPTH &&
            this->x != this->y !=1 && this->z !=1 &&
            this->x != this->ROW && this->y != this->COL && this->z != DEPTH)
    {
        resize (this->ROW-2, this->COL-2, this->DEPTH-2);
        x--;
        y--;
        z--;
    }
}


void printEnd()
{
    system ("cls");
    cout << "XXXXXXXXXXXXXXX XX XX XXX XXXXX XXX XXX XXX XXX XXX XXXXX XXX XXX" << endl;
    cout << "XXXXXXXXXXXXXXX XX XX XXXXX XXXXXX XXX XXX XXX XXX XXX XXX XXX XXX XXX" << endl;
    cout << " XXX XX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX" << endl;
    cout << " XXX XXXXXXXXX XXX XXX XXX XXX XXX XXXXXXX XXXXX XXX XXX XXX XXX" << endl;
    cout << " XXX XXXXXXXXX XXXXXXXXX XXX XXX XXX XXXXXXX XXXX XXX XXX XXX XXX" << endl;
    cout << " XXX XX XX XXXXXXXXXXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX" << endl;
    cout << " XXX XX XX XXX XXX XXX XXXXXX XXX XXX XXX XXX XXX XXX XXX " << endl;
    cout << " XXX XX XX XXX XXX XXX XXXXX XXX XXX XXX XXXXX XXXXXX " << endl;
    cout << " " << endl;
    cout << "XXXXXXXXXX XXXXX XXXXXXXX XXXXXXXX XX X XX XXX XX XXX XX XXXXXXX " << endl;
    cout << "XXXXXXXXXX XXX XXX XXXXXXXXX XXX XXXX XX XXX XX XXX XX XXXX XX XXXXX XX " << endl;
    cout << "XXX XXX XXX XXX XXX XXX XX XX XXXXX XX XXX XX XX XX XX XXXX " << endl;
    cout << "XXXXXX XXX XXX XXX XXX XXX XXX XX XX XXX XXXX XX XX XX XX XXX " << endl;
    cout << "XXXXXX XXX XXX XXXXXXXX XXXXXXX XX XXXXXXX XXX XX XX XX XX XXX XXXXX" << endl;
    cout << "XXX XXX XXX XXX XXX XXX XX XXXXXXXXX XXX XX XX XX XX XXXX XXX" << endl;
    cout << "XXX XXX XXX XXX XXX XXX XXXXXXX XX XXX XXX XX XX XXXXX XXXXXXXXXX " << endl;
    cout << "XXX XXXXX XXX XXX XXX XXXXXXX XX XXX XXX XX XX XXXX XXXXXX " << endl;
}

int main ()
{
    HANDLE hConsole;
    int k;

    hConsole = GetStdHandle(STD_OUTPUT_HANDLE);

    for(k = 1; k < 2; k++)
    {
        SetConsoleTextAttribute(hConsole, 26);
        char keyPressed;
        bool quit = false;
        int dX;
        int dY;
        int dZ;
        do
        {
            system("cls");
            cout <<endl;
            cout <<endl;
            cout <<"__xxxx___xxxx__xx__xxx____xxx__xxxxxx___xxxxxx___xxx___________xxx__xxxxxx__xxxxxx__xxxxx_____xxxxxx__xxxxxx__" << endl;
            cout <<"__xxxx___xxxx__xx__xxxx___xxx__xxxxxx__xxxxxxxx__xxx___________xxx__xxxxxx__xxxxxx__xxxxxxx___xxxxxx__xxxxxxx_"<< endl;
            cout <<"__xxxxx_xxxxx__xx__xxxx___xxx__xx______xxx__xxx__xxx___________xxx__xx______xx______xx___xxx__xx______xx___xx_"<< endl;
            cout <<"__xxx_xxx_xxx__xx__xxxxx__xxx__xx______xxx________xxx_________xxx___xx______xx______xx___xxx__xx______xx___xx_"<< endl;
            cout <<"__xxx_xxx_xxx__xx__xxx_xx_xxx__xxxxx____xxx_______xxx____x____xxx___xxxxx___xxxxx___xxxxxxx___xxxxx___xxxxxx__"<< endl;
            cout <<"__xxx__x__xxx__xx__xxx__xxxxx__xxxxx______xxx______xxx___x___xxx____xxxxx___xxxxx___xxx_______xxxxx___xxxx____"<< endl;
            cout <<"__xxx_____xxx__xx__xxx__xxxxx__xx___________xxx____xxx__xxx__xxx____xx______xx______xx________xx______xx_xx___"<< endl;
            cout <<"__xxx_____xxx__xx__xxx___xxxx__xx______xxx__xxx_____xxxx___xxxx_____xx______xx______xx________xx______xx__xx__"<< endl;
            cout <<"__xxx_____xxx__xx__xxx____xxx__xxxxxx__xxxxxxxx_____xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx__"<< endl;
            cout <<"__xxx_____xxx__xx__xxx____xxx__xxxxxx___xxxxxx______xxx_____xxx_____xxxxxx__xxxxxx__xx________xxxxxx__xx__xx__"<< endl;
            cout << endl;
            cout << endl;
            cout << endl;
            system("pause");

            cout <<" You may use the ESC button to quit MINESWEEPER anytime you wish" << endl;
            cout <<" The arrow buttons on your keyboard will be used to move your player around" << endl;
            cout <<" The buttons < and > will be used to go up and down levels" << endl;
            cout <<" The buttons = or - will be used to increse or decrease the size of your game" << endl;
            system("pause");
            cout << " Enter the number of rows you would like to have" << endl;
            cin >> dX;
            while (dX > MAX_ROW)
            {
                cout << " Please re-enter the number of rows you would like that is less than your previous entry" << endl;
                cin >> dX;
            }
            while (dX < MIN_ROW)
            {
                cout << " Please re-enter the number of rows you would like that is greater than your previous entry" << endl;
                cin >> dX;
            }
            cout << " Enter the number of columns you would like to have" << endl;
            cin >> dY;
            while (dY > MAX_COL)
            {
                cout << " Please re-enter the number of columns you would like that is less than your previous entry" << endl;
                cin >> dY;
            }
            while (dY < MIN_COL)
            {
                cout << " Please re-enter the number of columns you would like that is greater than your previous entry" << endl;
                cin >> dY;
            }
            cout << " Enter the depth you would like to have" << endl;
            cin >> dZ;
            while (dZ > MAX_DEPTH)
            {
                cout << " Please re-enter the depth you would like that is less than your previous entry" << endl;
                cin >> dZ;
            }
            while (dZ < MIN_DEPTH)
            {
                cout << " Please re-enter the depth you would like that is greater than your previous entry" << endl;
                cin >> dZ;
            }

            GridActive myGridActive (dX, dY, dZ);

            do
            {
                myGridActive.setActive ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ() );
                myGridActive.print ( myGridActive.getZ() );
                myGridActive.printDimensions ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ() );
                myGridActive.printDimensions ( myGridActive.getRow(), myGridActive.getCol(), myGridActive.getDepth() );
                keyPressed = toascii ( getch() );
                switch (keyPressed)
                {
                case 1:
                    quit = true;
                    break;
                case 2:
                    myGridActive.goDown ();
                    break;
                case 3:
                    myGridActive.goUp ();
                    break;
                case 4:
                    myGridActive.upsize ();
                    break;
                case 5:
                    system ("cls");
                    break;
                case 6:
                    myGridActive.downsize ();
                    break;
                case 7:
                    {
                        keyPressed = toascii (getch() );
                        switch (keyPressed)
                        {
                        case 8:
                            myGridActive.goNorth ();
                            break;
                        case 9:
                            myGridActive.goSouth ();
                            break;
                        case 10:
                            myGridActive.goWest ();
                            break;
                        case 11:
                            myGridActive.goEast ();
                            break;
                        default:
                            break;
                        }
                    default:
                        break;
                    }
                }
            }
            while (!quit);
            cout << "\n Would you like to start over? Press any key \n Would you like to quit? Press N ";
            keyPressed = getch ();
            quit = false;
            if (( keyPressed == 'N' ) || (keyPressed == 'n' ))
                quit = true;

            cin.get();
            printEnd();
        }while(2) ;
    }
}

#include <iostream> //For console output
#include <windows.h>   // WinApi header
#include <conio.h>
 
using namespace std;
 
 
#define minCOL  2  //minimum size allowed for number of columns
#define minROW 2  //minimum size allowed for number of rows
#define minDEPTH 2  //minimum size allowed for the depth
#define maxCOL 12 //maximum size allowed for number of columns
#define maxROW 12 //maximum size allowed for number of rows
#define maxDEPTH 12 //maximum size allowed for the depth
#define leftUPPER 201
#define verticalLINE 186
#define horizontalLINE     205
#define rightUPPER     187
#define leftLOWER     200
#define rightLOWER     188
#define intersection     206
#define verticalRightTURN     204
#define verticalLeftTURN     185
#define horizontalDownLINE     203
#define horizontalUpLINE     202
#define RROW 11;
#define RCOL 11;
#define emptyCELL     177
#define cursor     1
#define tail     219
#define num     6
 
 
class Room {
 
 
public:
 bool visited;
 bool active;
 Room(); // Default Constructor
 Room(bool visited, bool active); // Overloaded Constructor
 Room(const Room &node); //  Copy Constructor
 Room& operator= (const Room& node); // Operator
 ~Room(); //  Destructor/Destroyer
 
 
//Mutators
 void setActive (); // Gets the console ready to draw the minesweeper grid
 char draw (); // Draws the grid for minesweeper
};
 
 
Room::Room() {
 bool visited = NULL;
 bool active = NULL;
}

Room::Room(bool v, bool a) {
 visited = v;
 active = a;
}

Room::Room (const Room &node) {
 bool visited = node.visited;
 bool active = node.active;
}
 
Room& Room::operator=(const Room& node) {
 this->visited = node.visited;
 this->active = node.active;
 return *this;
}

void Room::setActive () {
 this->visited = true;
 this->active = true;
}

char Room::draw () {
 char ch = char (emptyCELL);
 if (visited) {
  ch = char (tail);
 }
 if (this->active) {
  ch = char (cursor);
  this->active = false;
 }
 return ch;
}

Room::~Room () {
}
/************************************************************************************************/
 

class Dynamic3DArray {
protected:
 int ROW;
 int COL;
 int DEPTH;
 Room*** array;
public:
 Dynamic3DArray (); // Default Consturtor
 Dynamic3DArray (int row, int col, int depth); // Overloaded Constructor
 Dynamic3DArray (const Dynamic3DArray& dynamic3DArray); // Copy Constructor
 Dynamic3DArray& operator= (const Dynamic3DArray& dynamic3DArray); //Assignment Operator
 ~Dynamic3DArray (); //Destroyer/Destructor
//Accessors
 int getROW (); //Gets the number of rows
 int getCOL (); //Gets the number of columns
 int getDEPTH (); //Gets the number for the depth
//Mutators
 void create (); //Will create a 3Dimentional grid
 void destroy (); //Destroys the grid to free memory
 void setActive (int x, int y, int z); //Will make the cells visited
 bool setDimentions (); //Will set the dimentions of the grid
 void resize (int x, int y, int z); //Will change the dimentions of the grid
 void print (int depth); //This prints the grid with the depth given by user
 void printDimensions (int x, int y, int z); //This prints the overall grid
};
Dynamic3DArray::Dynamic3DArray () {
 this-> ROW = 0;
 this-> COL = 0;
 this-> DEPTH = 0;
 array = NULL;
}

void Dynamic3DArray::create () {
 array = new Room** [ROW];
 for (int r=0; r<ROW; r++) {
  array[r] = new Room* [COL];
  for (int c=0; c<COL; c++) 
   array[r][c] = new Room [DEPTH];
 }
}

void Dynamic3DArray::destroy () {
 for (int r=0; r<ROW; r++) {
  for (int c=0; c<COL; c++)
   delete [] array [r][c];
  delete [] array [r];
 }
 delete [] array;
}

Dynamic3DArray::Dynamic3DArray (int row, int col, int depth) {
 this-> ROW = row;
 this-> COL = col;
 this-> DEPTH = depth;
 create ();
}

Dynamic3DArray::Dynamic3DArray (const Dynamic3DArray& dynamic3DArray) {
 this-> ROW = dynamic3DArray.ROW;
 this-> COL = dynamic3DArray.COL;
 this-> DEPTH = dynamic3DArray.DEPTH;
 create ();
 // copy values from dynamic3DArray
 for (int r=0; r<ROW; r++) {
  for (int c=0; c<COL; c++) {
   for (int d=0; d<DEPTH; d++)
    array[r][c][d]=dynamic3DArray.array[r][c][d];
  }
 }

}

void Dynamic3DArray::setActive (int x, int y, int z) {
 this-> array [x-1][y-1][z-1].setActive ();
}

void Dynamic3DArray::printDimensions (int x, int y, int z) {
 cout << "   < " << x << "," << y << "," << z << ">" << endl << endl;
}

void Dynamic3DArray::resize (int r, int c, int d) {
 Dynamic3DArray temp (*this);
 int mROW,
     mCOL,
  mDEPTH;
 //temp = *this;
 this-> destroy ();
 this-> ROW = r;
 this-> COL = c;
 this-> DEPTH = d;
 this-> create ();
 if (temp.ROW<ROW) 
  mROW = temp.ROW;
 else 
  mROW = ROW;
 if (temp.COL<COL)
  mCOL = temp.COL;
 else
  mCOL = COL;
 if (temp.DEPTH<DEPTH)
  mDEPTH = temp.DEPTH;
 else
  mDEPTH = DEPTH;
/********************************************************/
 for (int row=0; row<mROW; r++) {
  for (int col=0; col<mCOL; c++) {
   for (int depth=0; depth<mDEPTH; d++) {
    this->array[row][col][depth]=temp.array[row+1][col+1][depth+1];
   }
  }
 }

/*
  for (int r=0; r<temp.ROW; r++) {
   for (int c=0; c<temp.COL; c++) {
    for (int d=0; d<temp.DEPTH; d++)
     this-> array[r+1][c+1][d+1]=temp.array[r][c][d];
   }
  }
 }
 else {
  for (int r=0; r<temp.ROW; r++) {
   for (int c=0; c<COL; c++) {
    for (int d=0; d<DEPTH; d++) {
     this->array[r][c][d]=temp.array[r+1][c+1][d+1];
    }
   }
  }
 }
 */
}
int Dynamic3DArray::getROW () {
 return this-> ROW;
}
int Dynamic3DArray::getCOL () {
 return this-> COL;
}
int Dynamic3DArray::getDEPTH () {
 return this->DEPTH;
}
Dynamic3DArray::~Dynamic3DArray () {
 destroy ();
}
Dynamic3DArray& Dynamic3DArray::operator=(const Dynamic3DArray& dynamic3DArray) {
 destroy ();
 this->ROW = dynamic3DArray.ROW;
 this->COL = dynamic3DArray.COL;
 this->DEPTH = dynamic3DArray.DEPTH;
 create ();
 for (int r=0; r<ROW; r++) {
  for (int c=0; c<COL; c++) {
   for (int d=0; d<DEPTH; d++)
    array[r][c][d]=dynamic3DArray.array[r][c][d];
  }
 }
 return *this;
}
void Dynamic3DArray::print (int depth) {
 system ("cls");
 cout << char (leftUPPER);
 for (int r=0; r<ROW; r++) {
  cout << char (horizontalLINE) << char (horizontalDownLINE);
 }
 cout << "\b" << char (rightUPPER) << endl;
 for (int c=0; c<COL; c++) {
  cout << char (verticalLINE);
  for (int r=0; r<ROW; r++) {
   cout << array[r][c][depth-1].draw () << char (verticalLINE);
  }
  cout << "\b" << char (verticalRightTURN);
  if (c< (COL-1)) {
   for (int i=0; i<ROW; i++) {
    cout << char (horizontalLINE) << char (intersection);
   }
   cout << "\b" << char (verticalLeftTURN) << "\n";
  }
  else {
   cout << "\b" << char (leftLOWER);
   for (int r=0; r<ROW; r++) {
    cout << char (horizontalLINE) << char (horizontalUpLINE);
   }
  }
 }
 cout << "\b" << char (rightLOWER) << "\n";
}

/************************************************************************************************/
 
class GridActive:Dynamic3DArray {
private:
 int x;
 int y;
 int z;
public:
 GridActive ();
 GridActive (int R, int C, int D);
 GridActive (const GridActive & grid);
 ~GridActive ();
 GridActive& GridActive::operator= (const GridActive & grid);
 
//Accessors
 bool goNorth ();
 bool goSouth ();
 bool goWest ();
 bool goEast ();
 bool goUp ();
 bool goDown ();
 int getRow ();
 int getCol ();
 int getDepth ();
 int getX ();
 int getY ();
 int getZ ();
//Mutators
 void upsize ();
 void downsize ();
 void setActive ();
 void printDimensions (int x, int y, int z);
 void print (int dep);
 void GridActive::setActive (int x, int y, int z);
};
GridActive::GridActive ():Dynamic3DArray () {
 x=0;
 y=0;
 z=0;
}
GridActive::GridActive (int R, int C, int D):Dynamic3DArray (R, C, D) {
 x=R/2;
 y=C/2;
 z=D/2;
}
GridActive::~GridActive () {
}
GridActive::GridActive (const GridActive & grid):Dynamic3DArray(grid) {
 this->x = grid.x;
 this->y = grid.y;
 this->z = grid.z;
}
GridActive& GridActive::operator= (const GridActive & grid) {
 destroy ();
 this->x = grid.x;
 this->y = grid.y;
 this->z = grid.z;
 this->ROW = grid.ROW;
 this->COL = grid.COL;
 this->DEPTH = grid.DEPTH;
 create ();
 for (int r=0; r<ROW; r++) {
  for (int c=0; c<COL; c++) {
   for (int d=0; d<DEPTH; d++)
   array[r][c][d] = grid.array[r][c][d];
  }
 }
 return *this;
}
bool GridActive::goNorth () {
 if (y <= 0) return false;
 y--;
 return true;
}
bool GridActive::goSouth () {
 if (y >= COL-1) return false;
 y++;
 return true;
}
bool GridActive::goDown () {
 if (z <= 0) return false;
 z--;
 return true;
}
bool GridActive::goUp () {
 if (z >= DEPTH-1) return false;
 z++;
 return true;
}
bool GridActive::goEast () {
 if (x >= ROW-1) return false;
 x++;
 return true;
}
bool GridActive::goWest () {
 if (x <= 0) return false;
 x--;
 return true;
}
int GridActive::getRow () {
 return ROW;
}
int GridActive::getCol () {
 return COL;
}
int GridActive::getDepth () {
 return DEPTH;
}
void GridActive::print (int dep) {
 Dynamic3DArray::print (dep);
}
int GridActive::getX () {
 return x;
}
int GridActive::getY () {
 return y;
}
int GridActive::getZ () {
 return z;
}
void GridActive::setActive (int x, int y, int z) {
 Dynamic3DArray::setActive (x, y, z);
}
void GridActive::printDimensions (int x, int y, int z) {
 Dynamic3DArray::printDimensions (x, y, z);
}
void GridActive::upsize() {
 if ((ROW< maxROW-2) && (COL<maxCOL-2) && (DEPTH< maxDEPTH-2)) {
  resize (this->ROW+2, this->COL+2, this->DEPTH+2);
  x++;
  y++;
  z++;
  /***********************/
 }
}
void GridActive::downsize () {
 if (ROW > minROW && COL > minCOL && DEPTH > minDEPTH &&
  this->x != this->y !=1 && this->z !=1 &&
  this->x != this->ROW && this->y != this->COL && this->z != DEPTH) {
  resize (this->ROW-2, this->COL-2, this->DEPTH-2);
  x--;
  y--;
  z--;
  /*************************/
 }
}
 
 
void printEnd() {
 system ("cls");
 cout << "XXXXXXXXXXXXXX_XX____XX_____X_____XXXX______XX_XX____XX______XX____XX____XXXXX______XXX_____XXX_" << endl;
 cout << "XXXXXXXXXXXXXX_XX____XX____XXX____XXXXX_____XX_XX___XX_______XX___XX___XXX___XXX____XXX_____XXX_" << endl;
 cout << "______XX_______XX____XX___XX_XX___XX_XXX____XX_XX__XX________XX__XX__XXX_______XXX__XXX_____XXX_" << endl;
 cout << "______XX_______XXXXXXXX__XX___XX__XX__XXX___XX_XXXXX_________XXXX___XXX_________XXX_XXX_____XXX_" << endl;
 cout << "______XX_______XXXXXXXX__XXXXXXX__XX___XXX__XX_XXXXX_________XXX____XXX_________XXX_XXX_____XXX_" << endl;
 cout << "______XX_______XX____XX_XXXXXXXXX_XX____XXX_XX_XX___XX_______XX______XXX_______XXX__XXX_____XXX_" << endl;
 cout << "______XX_______XX____XX_XX_____XX_XX_____XXXXX_XX____XX______XX________XXX___XXX_____XXX___XXX__" << endl;
 cout << "______XX_______XX____XX_XX_____XX_XX______XXXX_XX_____XX_____XX__________XXXXX________XXXXXX____" << endl;
 cout << "________________________________________________________________________________________________" << endl;
 cout << "XXXXXXXXX_____XXXXX______XXXXXXX____XXXXXXXX    XX          X     XX     XXX XX XXX       XX       XXXXXXX  " << endl;
 cout << "XXXXXXXXX___XXX___XXX____XXXXXXXXX     XXX   XXXX  XX         XXX    XX   XXX   XX XXXX      XX    XXXXX    XX " << endl;
 cout << "XX________XXX_______XXX__XXX___XXX      XXX      XX XX        XXXXX   XX XXX     XX XX XX     XX  XXXX          " << endl;
 cout << "XXXXX____XXX_________XXX_XXX___XXX     XXX    XXX  XX       XX  XXX  XXXX      XX XX  XX    XX XXX            " << endl;
 cout << "XXXXX____XXX_________XXX_XXXXXXXX     XXXXXXX     XX       XXXXXXX  XXX      XX XX   XX   XX XXX       XXXXX" << endl;
 cout << "XX________XXX_______XXX__XX__XXX     XXX         XX     XXXXXXXXX XXX        XX XX    XX  XX  XXXX       XXX" << endl;
 cout << "XX__________XXX___XXX____XX___XXX     XXX         XXXXXXX XX    XXX XXX        XX XX     XXXXX    XXXXXXXXXX  " << endl;
 cout << "XX____________XXXXX______XX____XXX     XXX         XXXXXXX XX    XXX XXX        XX XX      XXXX       XXXXXX   " << endl;
}

void main () {
 HANDLE  hConsole;
 int k;
 
 hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
 
 for(k = 1; k < 2; k++) {
  SetConsoleTextAttribute(hConsole, 26);
 char keyPressed;
 bool quit = false;
 int dX;
 int dY;
 int dZ;
 do {
  system("cls");
  cout <<endl;
  cout <<endl;
  cout <<"xxx__xxx_xx_xx____xx_xxxxx__xxxx__xx_______xx_xxxxx_xxxxx_xxxxx___xxxxx_xxxxxx" << endl;
  cout <<"xxx__xxx_xx_xxx___xx_xxxxx_xxxxxx_xx_______xx_xxxxx_xxxxx_xxxxxx__xxxxx_xxxxxxx"<< endl;
  cout <<"xxx__xxx_xx_xxx___xx_xx____xxx_xx_xx_______xx_xx____xx____xx___xx_xx____xx___xx"<< endl;
  cout <<"xx_xx_xx_xx_xxxx__xx_xx____xx______xx_____xx__xx____xx____xx___xx_xx____xx___xx"<< endl;
  cout <<"xx_xx_xx_xx_xx_xx_xx_xxxxx__xx_____xx__x__xx__xxxxx_xxxxx_xxxxxx__xxxxx_xxxxxx"<< endl;
  cout <<"xx____xx_xx_xx__xxxx_xxxxx___xx____xx__x__xx__xxxxx_xxxxx_xxx_____xxxxx_xxxx"<< endl;
  cout <<"xx____xx_xx_xx__xxxx_xx_______xx___xx_xxx_xx__xx____xx____xx______xx____xx_xx"<< endl;
  cout <<"xx____xx_xx_xx___xxx_xx____xx_xxx___xxx_xxx___xx____xx____xx______xx____xx__xx"<< endl;
  cout <<"xx____xx_xx_xx____xx_xxxxx_xxxxxx___xx___xx___xxxxx_xxxxx_xx______xxxxx_xx__xx"<< endl;
  cout <<"xx____xx_xx_xx____xx_xxxxx__xxxx____xx___xx___xxxxx_xxxxx_xx______xxxxx_xx__xx"<< endl;
  cout << endl;
  cout << endl;
  cout << endl;
  system("pause");

 cout <<"You may use the ESC button to quit MINESWEEPER anytime you wish" << endl;
 cout <<"The arrow buttons on your keyboard will be used to move your player around" << endl;
 cout <<"The buttons < and > will be used to go up and down levels" << endl;
 cout <<"The buttons = or - will be used to increse or decrease the size of your game" << endl;
 system("pause");
 cout << " Enter the number of rows you would like to have" << endl;
 cin >> dX;
 while (dX > maxROW) {
  cout << " Please re-enter the number of rows you would like that is less than your previous entry" << endl;
  cin >> dX;
 }
 while (dX < minROW) {
  cout << " Please re-enter the number of rows you would like that is greater than your previous entry" << endl;
  cin >> dX;
 }
 cout << " Enter the number of columns you would like to have" << endl;
 cin >> dY;
 while (dY > maxCOL) {
  cout << " Please re-enter the number of columns you would like that is less than your previous entry" << endl;
  cin >> dY;
 }
 while (dY < minCOL) {
  cout << " Please re-enter the number of columns you would like that is greater than your previous entry" << endl;
  cin >> dY;
 }
 cout << " Enter the depth you would like to have" << endl;
 cin >> dZ;
 while (dZ > maxDEPTH) {
  cout << " Please re-enter the depth you would like that is less than your previous entry" << endl;
  cin >> dZ;
 }
 while (dZ < minDEPTH) {
  cout << " Please re-enter the depth you would like that is greater than your previous entry" << endl;
  cin >> dZ;
 }
 
 GridActive myGridActive (dX, dY, dZ);
 
 do{
  myGridActive.setActive ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ() );
  myGridActive.print ( myGridActive.getZ() );
  myGridActive.printDimensions ( myGridActive.getX(), myGridActive.getY(), myGridActive.getZ() );
  myGridActive.printDimensions ( myGridActive.getRow(), myGridActive.getCol(), myGridActive.getDepth() );
  keyPressed = toascii ( getch() );
  switch (keyPressed) {
   case 1:
    quit = true;
    break;
   case 2:
    myGridActive.goDown ();
    break;
   case 3:
    myGridActive.goUp ();
    break;
   case 4:
    myGridActive.upsize ();
    break;
   case 5:
    system ("cls");
    break;
   case 6:
    myGridActive.downsize ();
    break;
   case 7: {
    keyPressed = toascii (getch() );
    switch (keyPressed) {
     case 8:
      myGridActive.goNorth ();
      break;
     case 9:
      myGridActive.goSouth ();
      break;
     case 10:
      myGridActive.goWest ();
      break;
     case 11:
      myGridActive.goEast ();
      break;
     default: break;
    }
    default: break;
   }
  }
 }
  while (!quit);
  cout << "\n Would you like to start over? Press any key \n  Would you like to quit? Press N ";
  keyPressed = getch ();
  quit = false;
  if (( keyPressed == 'N' ) || (keyPressed == 'n' ))
  quit = true;

  cin.get();
  printEnd();
  }
 while(2);
 }
}

the code is error free and runs but now does not run right.
when you run it it should look like this which is the teachers

[IMG]http://i69.photobucket.com/albums/i79/xXlaurenbabyXx/game3.jpg[/IMG]


mine should in a way look like this

[IMG]http://i69.photobucket.com/albums/i79/xXlaurenbabyXx/game2.jpg[/IMG]


but instead looks like this


[IMG]http://i69.photobucket.com/albums/i79/xXlaurenbabyXx/game1.jpg[/IMG]

how do i fix mine?

More indentation is needed. Please use 3-4 spaces. 1 is not enough.

I'm not going to search through 580 lines of code, so I can only suggest you look at the output and make sure you have a RETURN at the end of each line. That's what it looks like.

By the way, you can post only the code section you need help with...