View difference between Paste ID: jGAgEdXj and rR2h8DTk

 ///////////////////////////////////////////////////////////////////////////////
 // Grid Game
 ///////////////////////////////////////////////////////////////////////////////
 // Grid game board program that lets users move a cursor around on a board
 ///////////////////////////////////////////////////////////////////////////////
 
 // Small define for if project were in multiple files
 //#define USE_SEPARATE_FILES
 
 #ifndef USE_SEPARATE_FILES
 #include <stdio.h>      // For I/O
 #include <stdlib.h>     // For rand
 #include <time.h>       // For seeding Rand
 #include <string>     // For memset
 #endif
 
-#define USE_SEPARATE_FILES
+
 #if defined _WIN32 || defined __CYGWIN__
 #include <windows.h>
 #endif
 
 
 #ifdef USE_SEPARATE_FILES
 #include "RenderContext.h"
 #include "I_Drawable.h"
 #include "GameBoard.h"
 #ifdef WIN32
 #include "CmdPromptHelper.h"
 #endif
 #else
 
 // RenderContext
 #ifndef USE_SEPARATE_FILES
 // Class that acts a canvas for things to draw to
 class RenderContext {
 private:
    int m_width, m_height; // Width and Height of this canvas
    char* m_renderBuffer; // Array to hold "pixels" of canvas
    char m_clearChar; // What to clear the array to
 
 public:
    // Empty Constructor
    RenderContext() : m_width(50), m_height(20), m_clearChar(' ') {
       m_renderBuffer = new char[m_width * m_height];
    }
 
    // Construct to specify width and height of canvas
    RenderContext(int width, int height) : m_width(width), m_height(height), m_clearChar(' ') {
       m_renderBuffer = new char[m_width * m_height];
    }
 
    // Destructor
    ~RenderContext() {
       if (m_renderBuffer) {
          delete m_renderBuffer;
       }
    }
 
    // Get a specific "pixel" on a canvas
    char getContentAt(int x, int y) {
       if (((0 <= x) && (x < m_width)) && ((0 <= y) && (y < m_height))) {
          return m_renderBuffer[(x + (y * m_width))];
       }
    }
 
    // Fill a specific "pixel" on the canvas
    void setContentAt(int x, int y, char val) {
       if (((0 <= x) && (x < m_width)) && ((0 <= y) && (y < m_height))) {
          m_renderBuffer[(x + (y * m_width))] = val;
       }
    }
 
    // Change what this canvas is flooded with when cleared
    void setClearChar(char clearChar) {
       m_clearChar = clearChar;
    }
 
    // Paint the canvas to the shell
    void render() {
       int row, column;
       for (row = 0; row < m_height; row++) {
          for (column = 0; column < m_width; column++) {
             printf("%c", getContentAt(column, row));
          }
          printf("\n");
       }
    }
 
    // Clear the canvas
    void clear() {
       memset(m_renderBuffer, m_clearChar, m_width * m_height);
    }
 };
 #endif
 
 // I_Drawable
 #ifndef USE_SEPARATE_FILES
 // Interface that allows objects to draw to the canvas
 class I_Drawable {
 public:
    // Virtual function that draws to the canvas
    virtual void draw(RenderContext&) = 0;
 };
 #endif
 
 // Marker
 #ifndef USE_SEPARATE_FILES
 // Class representing the cursor that selects objects on a game board
 class Marker : public I_Drawable {
 private:
    int m_xPos, m_yPos; // Position of cursor
 public:
    // Empty constructor
    Marker() : m_xPos(0), m_yPos(0) {
    }
    // Parameterized constructor allowing for setting of initial position
    Marker(int xPos, int yPos) : m_xPos(xPos), m_yPos(yPos) {
    }
    // Draw the cursor to the canvas
    void draw(RenderContext& renderTarget) {
 
       // Adjust marker by board spacing
       // (This is kind of a hack and should be changed)
       int tmpX, tmpY;
       tmpX = ((m_xPos * 5) + 1);
       tmpY = ((m_yPos * 3) + 1);
 
       // Set surrounding elements
       renderTarget.setContentAt(tmpX - 0, tmpY - 1, '-');
       renderTarget.setContentAt(tmpX - 1, tmpY - 0, '|');
       renderTarget.setContentAt(tmpX - 0, tmpY + 1, '-');
       renderTarget.setContentAt(tmpX + 1, tmpY - 0, '|');
    }
    // Get x position
    int getXPos() {
       return m_xPos;
    }
    // Get y position
    int getYPos() {
       return m_yPos;
    }
    // Set x position
    void setXPos(int xPos) {
       m_xPos = xPos;
    }
    // Set y position
    void setYPos(int yPos) {
       m_yPos = yPos;
    }
 };
 #endif
 
 // MoveDirection
 #ifndef USE_SEPARATE_FILES
 // Enumeration to hold directions a cursor can move
 typedef enum {
    MD_UP,
    MD_DOWN,
    MD_LEFT,
    MD_RIGHT
 } MoveDirection;
 #endif
 
 // GameBoard
 #ifndef USE_SEPARATE_FILES
 // Class to represent the board of a game being played
 class GameBoard : public I_Drawable {
 private:
    int m_width, m_height; // Width and height of the board
    int m_verticalSpacing, m_horizontalSpacing; // Spaces between each element on the board
    Marker m_marker; // The cursor that will draw on this board
    int* m_board; // Array of elements on this board
 
    // Set a value at a spot on this board
    // (There is no actual padding on the board, so do not include vertical/horizontal spacing)
    void setAtPos(int x, int y, int val) {
       if (((0 <= x) && (x < m_width)) && ((0 <= y) && (x < m_height))) {
          m_board[(x + (y * m_width))] = val;
       }
    }
 
    // Actually create the board
    void generateBoard() {
       int row, column, randomNumber, valToLeft, valToTop;
 
       // Iterate over all rows and columns
       for (row = 0; row < m_height; row++) {
          for (column = 0; column < m_width; column++) {
             // Get the previous elements
             valToLeft = getAtPos(column - 1, row);
             valToTop = getAtPos(column, row - 1);
 
             // Generate random numbers until we have one
             // that is not the same as an adjacent element
             do {
                randomNumber = (2 + (rand() % 7));
             } while ((valToLeft == randomNumber) || (valToTop == randomNumber));
             setAtPos(column, row, randomNumber);
          }
       }
    }
 
 public:
    // Empty Constructor
    GameBoard() : m_width(10), m_height(10), m_verticalSpacing(5), m_horizontalSpacing(3), m_marker(Marker()) {
       m_board = new int[m_width * m_height];
       generateBoard();
    }
 
    // Constructor that takes a width and height of a board
    GameBoard(int width, int height) : m_width(width), m_height(height), m_verticalSpacing(5), m_horizontalSpacing(3), m_marker(Marker()) {
       m_board = new int[m_width * m_height];
       generateBoard();
    }
 
    // Destructor
    ~GameBoard() {
       if (m_board) {
          delete m_board;
       }
    }
 
    // Function to get an element on the board
    // I would say overload operator() but it's often overkill
    // and can lead to hard to find bugs
    int getAtPos(int x, int y) {
       if (((0 <= x) && (x < m_width)) && ((0 <= y) && (x < m_height))) {
          return m_board[(x + (y * m_width))];
       }
    }
 
    // Function to draw to the canvas
    void draw(RenderContext& renderTarget) {
       int row, column;
       char buffer[8];
 
       // Iterate over every element
       for (row = 0; row < m_height; row++) {
          for (column = 0; column < m_width; column++) {
 
             // Convert the integer to a char
             sprintf(buffer, "%d", getAtPos(column, row));
 
             // Set the canvas "pixel" to the char at the
             // desired position including the padding
             renderTarget.setContentAt(
                     ((column * m_verticalSpacing) + 1),
                     ((row * m_horizontalSpacing) + 1),
                     buffer[0]);
          }
       }
 
       // Draw the marker
       m_marker.draw(renderTarget);
    }
 
    // Function to move the cursor around depending on input
    // (Does not allow the cursor to move off of the board)
    void handleInput(MoveDirection moveDirection) {
       switch (moveDirection) {
          case MD_UP:
             if (m_marker.getYPos() > 0) {
                m_marker.setYPos(m_marker.getYPos() - 1);
             }
             break;
          case MD_DOWN:
             if (m_marker.getYPos() < m_height - 1) {
                m_marker.setYPos(m_marker.getYPos() + 1);
             }
             break;
          case MD_LEFT:
             if (m_marker.getXPos() > 0) {
                m_marker.setXPos(m_marker.getXPos() - 1);
             }
             break;
          case MD_RIGHT:
             if (m_marker.getXPos() < m_width - 1) {
                m_marker.setXPos(m_marker.getXPos() + 1);
             }
             break;
       }
    }
 
    // Get the width of the board
    int getWidth() {
       return m_width;
    }
 
    // Get the height of the board
    int getHeight() {
       return m_height;
    }
 };
 #endif
 
 // CmdPromptHelper
 #ifndef USE_SEPARATE_FILES
 // This class is only useful if we are building on windows
 #ifdef WIN32
 
 // Class to help with drawing on the windows command prompt
 class CmdPromptHelper {
 private:
    DWORD inMode; // Attributes of std::in before we change them
    DWORD outMode; // Attributes of std::out before we change them
    HANDLE hstdin; // Handle to std::in
    HANDLE hstdout; // Handle to std::out
 public:
    // Empty constructor
    CmdPromptHelper() {
       // Get a handle to input of prompt
       hstdin = GetStdHandle(STD_INPUT_HANDLE);
       if ((hstdin == INVALID_HANDLE_VALUE)
               || !GetConsoleMode(hstdin, &inMode)
               || !SetConsoleMode(hstdin, 0)) {
          return;
       }
 
       // Get handle for output of prompt
       hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
       if ((hstdout == INVALID_HANDLE_VALUE)
               || !GetConsoleMode(hstdout, &outMode)) {
          return;
       }
    }
 
    // Revert the console
    void reset() {
       SetConsoleMode(hstdin, inMode);
    }
 
    // See what key is pressed by the user and return it
    WORD getKeyPress() {
       if (hstdin != INVALID_HANDLE_VALUE) {
          DWORD count;
-         // Return key
+
 
          // Get Key Press
          ReadConsoleInput(hstdin, &inrec, 1, &count);
 
          // Return key only if it is key down
          if (inrec.Event.KeyEvent.bKeyDown) {
             return inrec.Event.KeyEvent.wVirtualKeyCode;
          }
          else{
             return 0;
          }
 
          // Flush input
          FlushConsoleInputBuffer(hstdin);
       } else {
          return 0;
       }
    }
 
    // Flood the console with empty space so that we can
    // simulate single buffering (I have no idea how to double buffer this)
    void clearScreen() {
       if (hstdout != INVALID_HANDLE_VALUE) {
          CONSOLE_SCREEN_BUFFER_INFO csbi;
          DWORD cellCount; // How many cells to paint
          DWORD count; // How many we painted
          COORD homeCoord = {0, 0}; // Where to put the cursor when we're done
 
          // Get console info
          if (!GetConsoleScreenBufferInfo(hstdout, &csbi)) {
             return;
          }
 
          // Get cell count
          cellCount = csbi.dwSize.X * csbi.dwSize.Y;
 
          // Fill the screen with spaces
          FillConsoleOutputCharacter(
                  hstdout,
                  (TCHAR) ' ',
                  cellCount,
                  homeCoord,
                  &count
                  );
 
          // Set cursor position
          SetConsoleCursorPosition(hstdout, homeCoord);
       }
    }
 };
 #endif
 
 #endif
 
 #endif
 // Entry point of program
 int main() {
    // Create a game board
    GameBoard gb(5, 5);
 
    // Create something to render to
    RenderContext rc(25, 15);
    rc.setClearChar('.');
    rc.clear();
 
    // If on windows, we can animate
 #ifdef WIN32
    // Make a helper
    CmdPromptHelper cph;
 
    // Variable to hold key presses
    WORD key;
 
    // Play Game
    do {
       // Draw the board to the render object
       gb.draw(rc);
 
       // Draw the render object
       rc.render();
 
       // Get Key Press
       key = cph.getKeyPress();
 
       // Handle the key press
       switch (key) {
          case VK_UP:
             gb.handleInput(MD_UP);
             break;
          case VK_DOWN:
             gb.handleInput(MD_DOWN);
             break;
          case VK_LEFT:
             gb.handleInput(MD_LEFT);
             break;
          case VK_RIGHT:
             gb.handleInput(MD_RIGHT);
             break;
       }
 
       // Clear Screen
       rc.clear();
       cph.clearScreen();
 
    } while (key != VK_ESCAPE);
 
    // Reset console
    cph.reset();
 
    // If we aren't on windows, we can't animate and have
    // to write OS specific code to handle key presses
 #else
 
    // Variable to hold key presses
    char key;
 
    // Play Game
    do {
       // Draw the board to the render object
       gb.draw(rc);
 
       // Draw the render object
       rc.render();
 
       // Get Key Press
       key = getchar();
 
    } while (key != 0);
 
 #endif
 }
 
 // EoF