#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];

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...

This article has been dead for over six months. Start a new discussion instead.