Fixed a bug that allowed you to change direction twice within a single game tick

Author: Ubadub

Snake.cpp

@@ -4,7 +4,7 @@
 
 SDL_Color Snake::SNAKE_COLOR = {0x00, 0xFF, 0x00, SDL_ALPHA_OPAQUE}; // green
 
-Snake::Snake(int row, int col) : Snake(UP, row, col) {}
+Snake::Snake(int row, int col) : Snake(DIRECTION_UP, row, col) {}
 
 Snake::Snake(Snake::Direction d, int row, int col) :
 head_(new Block(row, col)),
@@ -103,8 +103,8 @@ void Snake::move()
 
 bool Snake::setDirectionIfPossible(Snake::Direction d)
 {
-    if ((direction_ == UP   && d == DOWN)  || (direction_ == DOWN  && d == UP)
-    ||  (direction_ == LEFT && d == RIGHT) || (direction_ == RIGHT && d == LEFT))
+    if ((direction_ == DIRECTION_UP   && d == DIRECTION_DOWN)  || (direction_ == DIRECTION_DOWN  && d == DIRECTION_UP)
+    ||  (direction_ == DIRECTION_LEFT && d == DIRECTION_RIGHT) || (direction_ == DIRECTION_RIGHT && d == DIRECTION_LEFT))
     {
         return false;
     }
@@ -134,16 +134,16 @@ std::pair<int, int> Snake::getNewRowAndColumn()
 
     switch (direction_)
     {
-        case UP:
+        case DIRECTION_UP:
             r -= 1;
             break;
-        case DOWN:
+        case DIRECTION_DOWN:
             r += 1;
             break;
-        case LEFT:
+        case DIRECTION_LEFT:
             c -= 1;
             break;
-        case RIGHT:
+        case DIRECTION_RIGHT:
             c += 1;
             break;
     }

Snake.h

@@ -12,10 +12,11 @@ class Snake
      */
     enum Direction
     {
-        UP,
-        DOWN,
-        LEFT,
-        RIGHT
+        DIRECTION_NONE = -1,
+        DIRECTION_UP,
+        DIRECTION_DOWN,
+        DIRECTION_LEFT,
+        DIRECTION_RIGHT
     };
 
     Snake(int row, int col);

SnakeBoard.cpp

@@ -1,7 +1,6 @@
 #include <iostream>
 #include <utility>
 
-#include "SnakeGame.h"
 #include "SnakeBoard.h"
 
 const SDL_Color SnakeBoard::FOOD_COLOR = {0xFF, 0xFF, 0x00, SDL_ALPHA_OPAQUE}; // yellow

SnakeBoard.h

@@ -2,8 +2,10 @@
 #define SNAKE_SNAKE_BOARD_H
 
 #include <utility>
+
 #include <SDL2/SDL.h>
 #include <SDL2_ttf/SDL_ttf.h>
+
 #include "Snake.h"
 
 class SnakeBoard
@@ -13,8 +15,8 @@ class SnakeBoard
      * An enum representing the four directions in which a Snake can travel.
      */
 
-    static const int COLUMNS = 10;
-    static const int ROWS = 10;
+    static const int COLUMNS = 20;
+    static const int ROWS = 20;
 
     static const int WINDOW_HEIGHT = 720;
     static const int WINDOW_WIDTH = WINDOW_HEIGHT;
@@ -48,14 +50,14 @@ class SnakeBoard
     bool snakeAte();
 
 private:
-    static const SDL_Color GRID_LINE_COLOR;
     static const SDL_Color FOOD_COLOR;
     static const SDL_Color FONT_COLOR;
     static const char FONT_LOCATION[];
     static const int GAME_OVER_FONT_SIZE = 1000;
+    static const SDL_Color GRID_LINE_COLOR;
     static const int SCORE_FONT_SIZE = 72;
 
-    std::pair<int, int> foodCoords_; // row and column of the food (0 <= c < COLUMNS, 0 <= r < ROWS)
+    std::pair<int, int> foodCoords_; // row and column of the food (0 <= r < ROWS, 0 <= c < COLUMNS)
 
     TTF_Font *game_over_msg_font_;
     SDL_Surface *game_over_msg_surface_;

SnakeGame.cpp

@@ -19,21 +19,26 @@ SnakeGame::~SnakeGame()
 
 void SnakeGame::loop()
 {
+    Snake::Direction d = Snake::DIRECTION_NONE;
     do
     {
         if (!paused_ && SDL_GetTicks() > time_ + DELAY)
         {
+            if (d != Snake::DIRECTION_NONE)
+            {
+                board_->setSnakeDirection(d);
+            }
             update();
             if (board_->isGameOver())
             {
                 gameOver();
             }
             time_ = SDL_GetTicks();
         }
-    } while(checkUserInput());
+    } while(checkUserInput(d));
 }
 
-bool SnakeGame::checkUserInput()
+bool SnakeGame::checkUserInput(Snake::Direction &d)
 {
     SDL_Event e;
     if (SDL_PollEvent(&e))
@@ -42,32 +47,33 @@ bool SnakeGame::checkUserInput()
         {
             case SDL_KEYDOWN:
             {
-                // If the game is paused, ignore all user input except unpause
-                if (paused_ && e.key.keysym.sym == SDLK_p)
-                {
-                    paused_ = false;
-                }
-                else if (!paused_)
+                if (!paused_)
                 {
+
                     switch (e.key.keysym.sym)
                     {
                         case SDLK_UP:
-                            board_->setSnakeDirection(Snake::UP);
+                            d = Snake::DIRECTION_UP;
                             break;
                         case SDLK_DOWN:
-                            board_->setSnakeDirection(Snake::DOWN);
+                            d = Snake::DIRECTION_DOWN;
                             break;
                         case SDLK_LEFT:
-                            board_->setSnakeDirection(Snake::LEFT);
+                            d = Snake::DIRECTION_LEFT;
                             break;
                         case SDLK_RIGHT:
-                            board_->setSnakeDirection(Snake::RIGHT);
+                            d = Snake::DIRECTION_RIGHT;
                             break;
                         case SDLK_p:
                             paused_ = true;
                             break;
                     }
                 }
+                // If the game is paused, ignore all user input except unpause
+                else
+                {
+                    paused_ = e.key.keysym.sym != SDLK_p;
+                }
             }
             break;
 

SnakeGame.h

@@ -12,7 +12,7 @@
 class SnakeGame
 {
 public:
-    static const int DELAY = 250;
+    static const int DELAY = 100;
 
     SnakeGame();
     ~SnakeGame();
@@ -24,7 +24,7 @@ class SnakeGame
     int score_;
     int time_;
 
-    bool checkUserInput();
+    bool checkUserInput(Snake::Direction &d);
 
     void gameOver();