output: add todos for later

src/botinterface.cpp

@@ -6,93 +6,106 @@
 #include <iostream>
 #include <queue>
 #include <stdexcept>
-#include <SFML/System/Vector2.hpp>
 
 PlayerDirection lastKnownDirection = kNone;
 
-AISnake::AISnake() {
+AISnake::AISnake(void) {
     ;
 }
 
-PlayerDirection AISnake::GetInput(const sf::Vector2f* source)
+PlayerDirection AISnake::GetInput(void) {
-{
+    sf::Vector2f source(g_pEngine->GetHeadLocation());
     sf::Vector2f directionDelta;
-    if (!source)
+
-        return kUp;
+    while (!path.empty() && source == path.top())
-    while (*source == path.top() && !path.empty()) { path.pop(); }
+        path.pop();
-    if (path.empty()) { path.push(GetAnyOpenPath(*source)); }
+    if (path.empty()) {
-    directionDelta = *source - path.top();
+        if (g_pEngine->state.m_bSmart) {
-    path.pop();
+            return CurrentBestDecision();
-    if ((directionDelta.y == 1)
+        } else
-            && (lastKnownDirection != kDown))
+            path.push(GetAnyOpenPath());
-        { lastKnownDirection = kUp; }
+    }
-    else if ((directionDelta.y == -1)
+
-            && (lastKnownDirection != kUp)) 
+    try {
-        { lastKnownDirection = kDown; }
+        sf::Vector2f next = path.top();
-    else if ((directionDelta.x == 1)
+        if (g_pEngine->gameBoard.at(next.y).at(next.x).m_bSnake)
-            && (lastKnownDirection != kRight)) 
+            next = GetAnyOpenPath();
-        { lastKnownDirection = kLeft; }
+        directionDelta = source - next;
-    else if ((directionDelta.x == -1)
+        path.pop();
-            && (lastKnownDirection != kLeft)) 
+    } catch (const std::out_of_range& error) {
-        { lastKnownDirection = kRight; }
+        directionDelta = source - GetAnyOpenPath(); // Out of bounds
+        EmptyPath();
+    }
+
+    if ((directionDelta.y == 1) && (lastKnownDirection != kDown))
+        lastKnownDirection = kUp;
+    else if ((directionDelta.y == -1) && (lastKnownDirection != kUp)) 
+        lastKnownDirection = kDown;
+    else if ((directionDelta.x == 1) && (lastKnownDirection != kRight))
+        lastKnownDirection = kLeft;
+    else if ((directionDelta.x == -1) && (lastKnownDirection != kLeft))
+        lastKnownDirection = kRight;
     return lastKnownDirection;
 }
 
-void AISnake::UpdateProbability(int snakeSize)
+void AISnake::UpdateProbability(int snakeSize) {
-{
+    thresholdDFS = 1 - ((double) snakeSize) / 1000;
-    probabilityBFS = 1 - ((double) snakeSize) / 1000;
     return;
 }
 
-void AISnake::AdjustProbability(double amount)
+void AISnake::AdjustProbability(double amount) {
-{
+    thresholdDFS += amount;
-    probabilityBFS += amount;
+    if (thresholdDFS > 1.0)
-    if (probabilityBFS > 1.0) { probabilityBFS = 1.0; }
+        thresholdDFS = 1.0;
-    if (probabilityBFS < 0.0) { probabilityBFS = 0.0; }
+    if (thresholdDFS < 0.0)
+        thresholdDFS = 0.0;
     return;
 }
 
-void AISnake::AddIteration(const int size)
+void AISnake::AddIteration(const int size) {
-{
+    if (size > 40) {
-    if (size > 40) 
-    {
         UpdateAverage(size);
         double adjustmentAmount = 0.002;
-        if (average > size) { AdjustProbability(adjustmentAmount); }
+        if (average > size)
-        else { AdjustProbability(-adjustmentAmount); }
+            AdjustProbability(adjustmentAmount);
+        else
+            AdjustProbability(-adjustmentAmount);
     }
     std::cout << "[LOG - AI] Current average: " << average << std::endl;
     std::cout << "[LOG - AI] Previous iteration size: " << size << std::endl;
 }
 
 void AISnake::ResetPath(void) {
-    while (!path.empty()) { path.pop(); }
+    while (!path.empty())
+        path.pop();
 }
 
 // Gets a new path for the bot to follow
 // Uses DFS algorithm
-void AISnake::GetNewPath(const sf::Vector2f& source)
+void AISnake::GetNewPath(void) {
-{
     // Search for food
     // Probability-based approach for fun
     double roll = ((double) GenerateRandomNumber(RAND_MAX)) / ((double) RAND_MAX);
-    if (roll <= probabilityBFS) { BFS(source); } 
+    if (roll <= thresholdDFS)
-    else { DFS(source); }
+        BFS();
+    else
+        DFS();
+
     UnvisitBoard();
+
     if (pathFailed) {
         pathFailed = false;
         EmptyPath();
-        path.push(GetAnyOpenPath(source));
     } else {
         TrimPath();
         if (path.empty())
-            path.push(GetAnyOpenPath(source));
+            path.push(GetAnyOpenPath());
     }
 }
 
-void AISnake::BFS(const sf::Vector2f& source) {
+void AISnake::BFS(void) {
     std::queue<sf::Vector2f> search;
-    search.push(source);
+    search.push(g_pEngine->GetHeadLocation());
     while (!search.empty()) {
         sf::Vector2f currentLocation = search.front();
         search.pop();
@@ -112,8 +125,6 @@ void AISnake::BFS(const sf::Vector2f& source) {
                     botPathUnsanitized.push(nearby);
                     return;
                 }
-                if (nearby.x < 1 || nearby.y < 1)
-                    continue;
                 if (space->m_bVisited)
                     continue;
                 if (space->m_bSnake)
@@ -128,9 +139,9 @@ void AISnake::BFS(const sf::Vector2f& source) {
     pathFailed = true;
 }
 
-void AISnake::DFS(const sf::Vector2f& source) {
+void AISnake::DFS(void) {
     std::stack<sf::Vector2f> search;
-    search.push(source);
+    search.push(g_pEngine->GetHeadLocation());
     while (!search.empty()) {
         sf::Vector2f currentLocation = search.top();
         search.pop();
@@ -150,8 +161,6 @@ void AISnake::DFS(const sf::Vector2f& source) {
                     botPathUnsanitized.push(nearby);
                     return;
                 }
-                if (nearby.x < 1 || nearby.x > g_pEngine->GetGameBoundaries().x - 2)
-                    continue;
                 if (space->m_bVisited)
                     continue;
                 if (space->m_bSnake)
@@ -166,10 +175,10 @@ void AISnake::DFS(const sf::Vector2f& source) {
     pathFailed = true;
 }
 
-sf::Vector2f AISnake::GetAnyOpenPath(const sf::Vector2f& source) {
+sf::Vector2f AISnake::GetAnyOpenPath(void) {
     sf::Vector2f bail;
     std::array<sf::Vector2f, 4> paths;
-    paths.fill(source);
+    paths.fill(g_pEngine->GetHeadLocation());
     paths[0].x -= 1;
     paths[1].x += 1;
     paths[2].y -= 1;
@@ -177,6 +186,8 @@ sf::Vector2f AISnake::GetAnyOpenPath(const sf::Vector2f& source) {
 
     for (auto path : paths) {
         try {
+            if (path == -g_pEngine->GetCurrentDirectionRaw())
+                continue; // Impossible action
             bail = path;
             if (g_pEngine->gameBoard.at(path.y).at(path.x).m_bSnake)
                 continue;
@@ -222,3 +233,119 @@ void AISnake::EmptyPath(void) {
     while (!botPathUnsanitized.empty())
         botPathUnsanitized.pop();
 }
+
+// Main method for using AI snake
+PlayerDirection AISnake::CurrentBestDecision(void) {
+    // Reset probabilities
+    probabilityUp = 0.25;
+    probabilityDown = 0.25;
+    probabilityLeft = 0.25;
+    probabilityRight = 0.25;
+
+    // Calculate options
+    CheckLocalFreedom();
+    CheckFoodDirection();
+
+    // Deny impossible movement
+    RemoveImpossibleChoice();
+
+    // Make decision
+    if (probabilityUp > probabilityDown) {
+        if (probabilityUp < probabilityLeft)
+            return kLeft;
+        if (probabilityUp < probabilityRight)
+            return kRight;
+        return kUp;
+    } else {
+        if (probabilityDown < probabilityLeft)
+            return kLeft;
+        if (probabilityDown < probabilityRight)
+            return kRight;
+        return kDown;
+    }
+}
+
+// Improves probability based on amount of local open spaces
+// TODO: Add weights
+void AISnake::CheckLocalFreedom(void) {
+    std::array<sf::Vector2f, 4> choices;
+    std::array<double, 4> chances;
+    chances.fill(0);
+    choices.fill(g_pEngine->GetHeadLocation());
+    choices[0].y += 1;
+    choices[1].x += 1;
+    choices[2].y -= 1;
+    choices[3].x -= 1;
+    for (int i = 0; i < 4; ++i) {
+        try {
+            if (g_pEngine->gameBoard.at(choices[i].y).at(choices[i].x).m_bSnake) {
+                chances[i] = 0;
+                continue;
+            }
+            if (g_pEngine->gameBoard.at(choices[i].y).at(choices[i].x).m_bFood) {
+                chances[0] = 0;
+                chances[1] = 0;
+                chances[2] = 0;
+                chances[3] = 0;
+                chances[i] = 1;
+                break;
+            }
+        } catch (const std::out_of_range& error) {
+            chances[i] = 0;
+            continue;
+        }
+        double openSpaces = 0;
+        for (int j = -1; j < 2; ++j) {
+            for (int k = -1; k < 2; ++k) {
+                try {
+                    if (!g_pEngine->gameBoard.at(choices[i].y + j).at(choices[i].x + k).m_bSnake)
+                        ++openSpaces;
+                } catch (const std::out_of_range& error) {
+                    continue; // Out of bounds
+                }
+            }
+        }
+        chances[i] = openSpaces * 0.11111111111;
+    }
+    probabilityDown *= chances[0] * 4;
+    probabilityRight *= chances[1] * 4;
+    probabilityUp *= chances[2] * 4;
+    probabilityLeft *= chances[3] * 4;
+}
+
+// Improves probability that direction of food is best option
+// TODO: Add weights
+void AISnake::CheckFoodDirection(void) {
+    sf::Vector2f delta = g_pEngine->GetHeadLocation() - g_pEngine->GetFoodLocation();
+    if (delta.x > 0)
+        probabilityLeft *= 1.5;
+    if (delta.x < 0)
+        probabilityRight *= 1.5;
+    if (delta.y > 0)
+        probabilityUp *= 1.5;
+    if (delta.y < 0)
+        probabilityDown *= 1.5;
+}
+
+void AISnake::RemoveImpossibleChoice(void) {
+    if (g_pEngine->GetPlayerSize() == 1)
+        return; // Player can go any direction
+    PlayerDirection currentDirection = g_pEngine->GetCurrentDirection();
+    switch (currentDirection) {
+        case (kUp):
+            probabilityDown = 0;
+            break;
+        case (kDown):
+            probabilityUp = 0;
+            break;
+        case (kLeft):
+            probabilityRight = 0;
+            break;
+        case (kRight):
+            probabilityLeft = 0;
+            break;
+        default:
+            std::cout << "[ERR - AI] Impossibility defaulted somehow??" << std::endl;
+            break;
+    }
+}

src/botinterface.hpp

@@ -8,9 +8,9 @@
 class AISnake {
 public:
     std::stack<sf::Vector2f> path;
-    AISnake();
+    AISnake(void);
-    void GetNewPath(const sf::Vector2f& source);
+    void GetNewPath(void);
-    PlayerDirection GetInput(const sf::Vector2f* source);
+    PlayerDirection GetInput(void);
     void UpdateProbability(int snakeSize);
     void AdjustProbability(double amount);
     void AddIteration(const int size);
@@ -19,16 +19,30 @@ public:
 private:
     int totalLength = 0;
     double average = 0;
-    double probabilityBFS = 0.800;
+    double thresholdDFS = 0.900;
     bool pathFailed = false;
+
+    // Generic search algorithms
     std::stack<sf::Vector2f> botPathUnsanitized;
-    void BFS(const sf::Vector2f& source);
+    void BFS(void);
-    void DFS(const sf::Vector2f& source);
+    void DFS(void);
-    sf::Vector2f GetAnyOpenPath(const sf::Vector2f& source);
+    sf::Vector2f GetAnyOpenPath(void);
     void UnvisitBoard(void);
     void UpdateAverage(const int size);
     void TrimPath(void);
     void EmptyPath(void);
+
+    // Unsupervised learning
+    // Make decisions about current state of board
+    double probabilityUp = 0.25;
+    double probabilityDown = 0.25;
+    double probabilityLeft = 0.25;
+    double probabilityRight = 0.25;
+    PlayerDirection CurrentBestDecision(void);
+    void CheckLocalFreedom(void);
+    void CheckFoodDirection(void);
+    void RemoveImpossibleChoice(void);
+    
 };
 
 #endif 

src/common.cpp

@@ -3,14 +3,13 @@
 #include "common.hpp"
 
 std::default_random_engine generator;
-void InitializeGenerator(void)
+
-{
+void InitializeGenerator(void) {
     generator.seed(std::random_device{}());
 }
 
 // Returns a newly generated number
-int GenerateRandomNumber(int generationLimit)
+int GenerateRandomNumber(int generationLimit) {
-{
     int generatedNumber;
     std::uniform_int_distribution<> distribution(0, generationLimit - 1);
     generatedNumber = distribution(generator);

src/common.hpp

@@ -4,8 +4,7 @@
 void InitializeGenerator(void);
 int GenerateRandomNumber(int generationLimit);
 
-enum PlayerDirection
+enum PlayerDirection {
-{
     kNone = 0,
     kLeft = 1,
     kUp = 2,
@@ -14,7 +13,7 @@ enum PlayerDirection
 };
 
 struct GameSpace {
-    GameSpace();
+    GameSpace(void);
     unsigned char m_bFood : 1 = 0;
     unsigned char m_bSnake : 1 = 0;
     unsigned char m_bVisited : 1 = 0; // Used for BFS/DFS

src/gamestate.cpp

@@ -6,23 +6,20 @@
 #include "playerinterface.hpp"
 #include "gamestate.hpp"
 
-GameEngine::GameEngine()
+GameEngine::GameEngine(void) {
-{
     InitializeGenerator();
-    return;
 }
 
-void GameEngine::Start()
+void GameEngine::Start(void) {
-{
     PrepareGameBoard();
     if (!state.m_bNoDisplay)
         graphics.StartGameWindow();
+    if (state.m_bIsBotControlled)
+        graphics.SetShowGame(true);
     Loop();
-    return;
 }
 
-void GameEngine::Reset()
+void GameEngine::Reset(void) {
-{
     if (!state.m_bIsBotControlled)
         graphics.CheckContinue();
     else
@@ -30,21 +27,25 @@ void GameEngine::Reset()
     player.Reset();
     PrepareGameBoard();
     state.m_bIsGameOver = false;
-    if (state.m_bIsBotControlled) {
+    if (!state.m_bIsBotControlled)
+        return;
+    if (!state.m_bSmart) {
         while (!bot.path.empty())
             bot.path.pop();
-        if (state.m_bNoDisplay)
-            graphics.SetShowGame(false);
-        graphics.SetShowGame((bot.amountPlayed + 1) % 50 == 0);
     }
+    if (state.m_bNoDisplay)
+        graphics.SetShowGame(false);
+    if (state.m_bSkipIterations)
+        graphics.SetShowGame((bot.amountPlayed + 1) % 50 == 0);
+    // TODO: Replace with value to force this effect
+    graphics.SetShowGame(true);
 }
 
-void GameEngine::Loop(void)
+void GameEngine::Loop(void) {
-{
     int currentScore = 0;
-    while (graphics.IsOpen() || state.m_bNoDisplay)
+    while (graphics.IsOpen() || state.m_bNoDisplay) {
-    {
+        if (state.m_bIsGameOver)
-        if (state.m_bIsGameOver) { Reset(); }
+            Reset();
         UpdatePlayerSpeed();
         PlaceNewSnakePart(MovePlayer());
         RegenerateFood();
@@ -52,27 +53,54 @@ void GameEngine::Loop(void)
         if (!state.m_bNoDisplay)
             graphics.DisplayGameState(gameBoard, currentScore);
     }
-    return;
 }
 
-sf::Vector2f GameEngine::MovePlayer(void)
+sf::Vector2f GameEngine::MovePlayer(void) {
-{
     return sf::Vector2f(player.headLocation.x + player.speed.x, player.headLocation.y + player.speed.y);
 }
 
 
-sf::Vector2f GameEngine::GetGameBoundaries(void)
+sf::Vector2f GameEngine::GetGameBoundaries(void) {
-{
     return graphics.gameBoundaries;
 }
 
+PlayerDirection GameEngine::GetCurrentDirection(void) {
+    if (player.speed.x) {
+        if (player.speed.x > 0)
+            return kRight;
+        else
+            return kLeft;
+    } else {
+        if (player.speed.y > 0)
+            return kDown;
+        else
+            return kUp;
+    }
+}
+
+sf::Vector2f GameEngine::GetCurrentDirectionRaw(void) {
+    return player.speed;
+}
+
+int GameEngine::GetPlayerSize(void) {
+    return player.body.size();
+}
+
+sf::Vector2f GameEngine::GetHeadLocation(void) {
+    return player.headLocation;
+}
+
+sf::Vector2f GameEngine::GetFoodLocation(void) {
+    return playerFood.location;
+}
+
 void GameEngine::PlaceNewSnakePart(sf::Vector2f location) {
-    if (!player.speed.x && !player.speed.y) { return; }
+    if (!player.speed.x && !player.speed.y)
+        return;
     try {
         GameSpace* locationState = &gameBoard.at(location.y).at(location.x);
-        if (locationState->m_bSnake && (player.body.size() > 1)) {
+        if (locationState->m_bSnake && (player.body.size() > 1))
             state.m_bIsGameOver = true; // Game should end (Snake touching snake)
-        }
         locationState->m_bSnake = true;
         player.body.push(locationState);
         player.headLocation = location;
@@ -86,70 +114,70 @@ void GameEngine::PlaceNewSnakePart(sf::Vector2f location) {
     } catch (const std::out_of_range& error) {
         state.m_bIsGameOver = true; // Snake ran into edge
     }
-    return;
 }
 
 
 // Generates new food until not colliding with player
-void GameEngine::RegenerateFood()
+void GameEngine::RegenerateFood(void) {
-{
     // Generate a new food location if the current one is occupied
-    while (gameBoard.at(playerFood.location.y).at(playerFood.location.x).m_bSnake) {
+    while (gameBoard.at(playerFood.location.y).at(playerFood.location.x).m_bSnake)
         playerFood.GenerateNewFood(GetGameBoundaries());
-    }
 
     // Update the game board with the new food location
     gameBoard.at(playerFood.location.y).at(playerFood.location.x).m_bFood = 1;
 }
 
 
-void GameEngine::PrepareGameBoard(void)
+void GameEngine::PrepareGameBoard(void) {
-{
+    // Create empty game board
     gameBoard.clear();
     sf::Vector2f boardDimensions = GetGameBoundaries();
     gameBoard.resize(boardDimensions.y, std::vector<GameSpace>(boardDimensions.x));
+
     // Snake setup
     player.headLocation.x = GenerateRandomNumber(boardDimensions.x);
     player.headLocation.y = GenerateRandomNumber(boardDimensions.y);
-    {
+    GameSpace* locationState = &gameBoard.at(player.headLocation.y).at(player.headLocation.x);
-        GameSpace* locationState = &gameBoard.at(player.headLocation.y).at(player.headLocation.x);
+    player.body.push(locationState);
-        player.body.push(locationState);
+    locationState->m_bSnake = true;
-        locationState->m_bSnake = true;
+
-    }
     // Food setup
     playerFood.GenerateNewFood(boardDimensions);
     gameBoard.at(playerFood.location.y).at(playerFood.location.x).m_bFood = true;
     return;
 }
 
-void GameEngine::UpdatePlayerSpeed(void)
+void GameEngine::UpdatePlayerSpeed(void) {
-{
     PlayerDirection controller;
     if (state.m_bIsBotControlled) { 
-        if (bot.path.empty()) { 
+        if (bot.path.empty())
-            bot.GetNewPath(player.headLocation); 
+            bot.GetNewPath(); 
-        }
+        controller = bot.GetInput();
-        controller = bot.GetInput(&player.headLocation); 
+    } else
-    }
+        controller = GetPlayerInput();
-    else { controller = GetPlayerInput(); }
+
     switch (controller) { 
         case kUp:
-            if (player.speed.y == kUnitSpeed) { break; }
+            if (player.speed.y == kUnitSpeed)
+                break;
             player.speed.x = 0;
             player.speed.y = -kUnitSpeed;
             break;
         case kLeft:
-            if (player.speed.x == kUnitSpeed) { break; }
+            if (player.speed.x == kUnitSpeed)
+                break;
             player.speed.x = -kUnitSpeed;
             player.speed.y = 0;
             break;
         case kRight:
-            if (player.speed.x == -kUnitSpeed) { break; }
+            if (player.speed.x == -kUnitSpeed)
+                break;
             player.speed.x = kUnitSpeed;
             player.speed.y = 0;
             break;
         case kDown:
-            if (player.speed.y == -kUnitSpeed) { break; }
+            if (player.speed.y == -kUnitSpeed)
+                break;
             player.speed.x = 0;
             player.speed.y = kUnitSpeed;
             break;

src/gamestate.hpp

@@ -5,15 +5,15 @@
 #include <SFML/Graphics.hpp>
 #include <memory>
 #include "botinterface.hpp"
+#include "common.hpp"
 #include "snake.hpp"
 #include "playerinterface.hpp"
 
 const int kUnitSpeed = 1;
 
-class GameEngine
+class GameEngine {
-{
 public:
-    GameEngine();
+    GameEngine(void);
     void Start(void);
     void Reset(void);
     sf::Vector2f GetGameBoundaries(void);
@@ -21,13 +21,18 @@ public:
         unsigned char m_bIsGameOver : 1 = 0;
         unsigned char m_bIsBotControlled : 1 = 0;
         unsigned char m_bNoDisplay : 1 = 0;
-        unsigned char _3 : 1 = 0;
+        unsigned char m_bSmart : 1 = 0;
-        unsigned char _4 : 1 = 0;
+        unsigned char m_bSkipIterations : 1 = 0;
         unsigned char _5 : 1 = 0;
         unsigned char _6 : 1 = 0;
         unsigned char _7 : 1 = 0;
     } state;
     std::vector< std::vector<GameSpace> > gameBoard;
+    PlayerDirection GetCurrentDirection(void);
+    sf::Vector2f GetCurrentDirectionRaw(void);
+    int GetPlayerSize(void);
+    sf::Vector2f GetHeadLocation(void);
+    sf::Vector2f GetFoodLocation(void);
 private:
     PlayerOutput graphics;
     Snake player;
@@ -38,7 +43,7 @@ private:
     void PlaceNewSnakePart(sf::Vector2f location);
     void RegenerateFood(void);
     void PrepareGameBoard(void);
-    void UpdatePlayerSpeed();
+    void UpdatePlayerSpeed(void);
 };
 
 inline std::unique_ptr<GameEngine> g_pEngine;

src/main.cpp

@@ -28,6 +28,12 @@ int main(int argc, char* argv[]) {
         } else if (args[i].compare("--auto") == 0) {
             g_pEngine->state.m_bIsBotControlled = true;
             std::cout << "[LOG - Main] Bot control enabled" << std::endl;
+        } else if (args[i].compare("--smart") == 0) {
+            g_pEngine->state.m_bSmart = true;
+            std::cout << "[LOG - Main] Using AI" << std::endl;
+        } else if (args[i].compare("--skip") == 0) {
+            g_pEngine->state.m_bSkipIterations = true;
+            std::cout << "[LOG - Main] Only showing every 50 epochs" << std::endl;
         } else if (args[i].compare("-h") == 0 || args[i].compare("--help") == 0) {
             Help();
             return 0;

src/playerinterface.cpp

@@ -1,32 +1,30 @@
 #include "playerinterface.hpp"
 #include <SFML/System/Vector2.hpp>
 #include <SFML/Window/Keyboard.hpp>
-#include <iostream>
 
-PlayerDirection GetPlayerInput(void)
+PlayerDirection GetPlayerInput(void) {
-{
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left) ||
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left) 
+            (sf::Keyboard::isKeyPressed(sf::Keyboard::A)))
-            || sf::Keyboard::isKeyPressed(sf::Keyboard::A))
         return kLeft;
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up) ||
-            || sf::Keyboard::isKeyPressed(sf::Keyboard::W))
+            (sf::Keyboard::isKeyPressed(sf::Keyboard::W)))
         return kUp;
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down) ||
-            || sf::Keyboard::isKeyPressed(sf::Keyboard::S))
+            (sf::Keyboard::isKeyPressed(sf::Keyboard::S)))
         return kDown;
-    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right) ||
-            || sf::Keyboard::isKeyPressed(sf::Keyboard::D))
+            (sf::Keyboard::isKeyPressed(sf::Keyboard::D)))
         return kRight;
     return kNone;
 }
 
-bool PlayerOutput::IsOpen(void)
+bool PlayerOutput::IsOpen(void) {
-{
     return isWindowAlive;
 }
 
-PlayerOutput::PlayerOutput(void)
+// TODO: Add board size limits
-{
+//       Add gaps and a border that accommodate the limits
+PlayerOutput::PlayerOutput(void) {
     float kWidth = 1025;
     float kHeight = 725;
     float kBoardWidth = kWidth / kGridSize;
@@ -37,26 +35,23 @@ PlayerOutput::PlayerOutput(void)
     return;
 }
 
-void PlayerOutput::CheckContinue()
+void PlayerOutput::CheckContinue(void) {
-{
     DisplayEndScreen();
-    while (true)
+    while (true) {
-    {
         gameWindow.pollEvent(event);
-        if ((event.type == sf::Event::Closed)
+        if ((event.type == sf::Event::Closed) ||
-                || (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)))
+                (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))) {
-        {
             gameWindow.close();
             isWindowAlive = false;
             return;
         }
-        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Enter)) { return; }
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Enter))
+            return;
         sf::sleep(delay);
     }
 }
 
-void PlayerOutput::DisplayEndScreen(void)
+void PlayerOutput::DisplayEndScreen(void) {
-{
     gameWindow.clear();
     sf::Vector2f textPosition(gameBoundaries);
     textPosition.x = textPosition.x / 2;
@@ -80,24 +75,20 @@ void PlayerOutput::DisplayScore(int score) {
     sf::Text ScoreText(text, font);
     ScoreText.setPosition(textPosition);
     gameWindow.draw(ScoreText);
-    
 }
 
-void PlayerOutput::DisplayGameState(std::vector< std::vector<GameSpace> >& gameBoard, int score)
+void PlayerOutput::DisplayGameState(std::vector< std::vector<GameSpace> >& gameBoard, int score) {
-{
     CheckWindowEvents();
     if (delay == sf::milliseconds(0)) { return; }
     char* letterOnBoard;
-    for (float y = 0; y < gameBoundaries.y; y++)
+    for (float y = 0; y < gameBoundaries.y; y++) {
-    {
+        for (float x = 0; x < gameBoundaries.x; x++) {
-        for (float x = 0; x < gameBoundaries.x; x++)
-        {
             if (gameBoard.at(y).at(x).m_bSnake)
-                    DrawSnake(sf::Vector2f(x, y));
+                DrawSnake(sf::Vector2f(x, y));
             else if (gameBoard.at(y).at(x).m_bFood)
-                    DrawFood(sf::Vector2f(x,y));
+                DrawFood(sf::Vector2f(x,y));
             else
-                    DrawEmpty(sf::Vector2f(x,y));
+                DrawEmpty(sf::Vector2f(x,y));
         }
     }
     DisplayScore(score);
@@ -106,25 +97,22 @@ void PlayerOutput::DisplayGameState(std::vector< std::vector<GameSpace> >& gameB
     return;
 }
 
-void PlayerOutput::StartGameWindow(void)
+void PlayerOutput::StartGameWindow(void) {
-{
     gameWindow.create(gameVideoSettings, "SnakePlusPlus");
     isWindowAlive = true;
-    return;
 }
 
 void PlayerOutput::SetShowGame(bool isShowing) {
-    if (isShowing) { delay = sf::milliseconds(5); }
+    if (isShowing)
-    else { delay = sf::milliseconds(0); }
+        delay = sf::milliseconds(5);
-    return;
+    else
+        delay = sf::milliseconds(0);
 }
 
-void PlayerOutput::CheckWindowEvents(void)
+void PlayerOutput::CheckWindowEvents(void) {
-{
+    while (gameWindow.pollEvent(event)) {
-    while (gameWindow.pollEvent(event))
+        if ((event.type == sf::Event::Closed) || 
-    {
+                (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))) {
-        if ((event.type == sf::Event::Closed)
-                || (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))) {
             gameWindow.close();
             isWindowAlive = false;
         }
@@ -139,29 +127,23 @@ void PlayerOutput::CheckWindowEvents(void)
     }
 }
 
-void PlayerOutput::DrawEmpty(sf::Vector2f location)
+void PlayerOutput::DrawEmpty(sf::Vector2f location) {
-{
     location *= static_cast<float>(kGridSize);
     drawObject.setPosition(location);
     drawObject.setFillColor(sf::Color::Black);
     gameWindow.draw(drawObject);
-    return;
 }
 
-void PlayerOutput::DrawFood(sf::Vector2f location)
+void PlayerOutput::DrawFood(sf::Vector2f location) {
-{
     location *= static_cast<float>(kGridSize);
     drawObject.setPosition(location);
     drawObject.setFillColor(sf::Color::Red);
     gameWindow.draw(drawObject);
-    return;
 }
 
-void PlayerOutput::DrawSnake(sf::Vector2f location)
+void PlayerOutput::DrawSnake(sf::Vector2f location) {
-{
     location *= static_cast<float>(kGridSize);
     drawObject.setPosition(location);
     drawObject.setFillColor(sf::Color::Green);
     gameWindow.draw(drawObject);
-    return;
 }

src/playerinterface.hpp

@@ -8,13 +8,12 @@ const int kGridSize = 25;
 
 PlayerDirection GetPlayerInput(void);
 
-class PlayerOutput 
+class PlayerOutput {
-{
 public:
     sf::Vector2f gameBoundaries;
     PlayerOutput(void);
     bool IsOpen(void);
-    void CheckContinue();
+    void CheckContinue(void);
     void DisplayGameState(std::vector< std::vector<GameSpace> >& gameBoard, int score);
     void DisplayScore(int score);
     void StartGameWindow(void);

src/snake.cpp

@@ -3,25 +3,23 @@
 #include <SFML/Graphics.hpp>
 #include "common.hpp"
 #include "snake.hpp"
-
+ 
-void Snake::Pop(void)
+void Snake::Pop(void) {
-{
     body.front()->m_bSnake = false;
     body.pop();
     return;
 }
 
-void Snake::Reset(void)
+void Snake::Reset(void) {
-{
+    while (!body.empty())
-    while (!body.empty()) Pop();
+        Pop();
     speed.x = 0;
     speed.y = 0;
     return;
 }
 
 // Returns a new food object for the snakeFood
-void Food::GenerateNewFood(sf::Vector2f boundaries)
+void Food::GenerateNewFood(sf::Vector2f boundaries) {
-{
     location.x = GenerateRandomNumber(boundaries.x);
     location.y = GenerateRandomNumber(boundaries.y);
     return;

src/snake.hpp

@@ -6,8 +6,7 @@
 #include <queue>
 #include "common.hpp"
 
-struct Snake
+struct Snake {
-{
 public:
     sf::Vector2f headLocation;
     sf::Vector2f speed;
@@ -16,8 +15,7 @@ public:
     void Reset(void);
 };
 
-struct Food
+struct Food {
-{
 public:
     sf::Vector2f location;
     void GenerateNewFood(sf::Vector2f boundaries);