output: add todos for later

Reviewed-on: Trianta/snakeplusplus#6

.gitignore

@@ -33,7 +33,20 @@
 *.json
 *.ps1
 
+# ---> CMake
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+build
+
 # Extras
 .vs*
-build
+.cache
-bin

CMakeLists.txt

@@ -4,7 +4,7 @@ project(
     snakeplusplus
     LANGUAGES CXX)
 
-set(CMAKE_CXX_STANDARD 11 CACHE STRING "The C++ standard to use")
+set(CMAKE_CXX_STANDARD 23 CACHE STRING "The C++ standard to use")
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

src/botinterface.cpp

@@ -1,77 +1,116 @@
 #include "botinterface.hpp"
 #include "common.hpp"
+#include "gamestate.hpp"
 #include <array>
 #include <cstdlib>
+#include <iostream>
 #include <queue>
 #include <stdexcept>
-#include <SFML/System/Vector2.hpp>
 
-namespace snakeplusplus
-{
 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 == path.top()) { path.pop(); }
+
-        if (path.empty()) { return kUp; } // Snake is trapped
+    while (!path.empty() && source == path.top())
-        directionDelta = *source - path.top();
         path.pop();
-        if ((directionDelta.y == 1)
+    if (path.empty()) {
-                && (lastKnownDirection != kDown))
+        if (g_pEngine->state.m_bSmart) {
-            { lastKnownDirection = kUp; }
+            return CurrentBestDecision();
-        else if ((directionDelta.y == -1)
+        } else
-                && (lastKnownDirection != kUp)) 
+            path.push(GetAnyOpenPath());
-            { lastKnownDirection = kDown; }
+    }
-        else if ((directionDelta.x == 1)
+
-                && (lastKnownDirection != kRight)) 
+    try {
-            { lastKnownDirection = kLeft; }
+        sf::Vector2f next = path.top();
-        else if ((directionDelta.x == -1)
+        if (g_pEngine->gameBoard.at(next.y).at(next.x).m_bSnake)
-                && (lastKnownDirection != kLeft)) 
+            next = GetAnyOpenPath();
-            { lastKnownDirection = kRight; }
+        directionDelta = source - next;
+        path.pop();
+    } catch (const std::out_of_range& error) {
+        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) {
+    thresholdDFS = 1 - ((double) snakeSize) / 1000;
+    return;
+}
+
+void AISnake::AdjustProbability(double amount) {
+    thresholdDFS += amount;
+    if (thresholdDFS > 1.0)
+        thresholdDFS = 1.0;
+    if (thresholdDFS < 0.0)
+        thresholdDFS = 0.0;
+    return;
+}
+
+void AISnake::AddIteration(const int size) {
+    if (size > 40) {
+        UpdateAverage(size);
+        double adjustmentAmount = 0.002;
+        if (average > size)
+            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();
+}
+
 // Gets a new path for the bot to follow
 // Uses DFS algorithm
-    void AISnake::GetNewPath(const std::vector< std::vector<char> >& gameBoard, const sf::Vector2f& source, const sf::Vector2f& boundaries, const int snakeSize)
+void AISnake::GetNewPath(void) {
-    {
     // Search for food
-        if (snakeSize < 135) {
+    // Probability-based approach for fun
-            BFS(gameBoard, source, boundaries);
+    double roll = ((double) GenerateRandomNumber(RAND_MAX)) / ((double) RAND_MAX);
+    if (roll <= thresholdDFS)
+        BFS();
+    else
+        DFS();
+
+    UnvisitBoard();
+
+    if (pathFailed) {
+        pathFailed = false;
+        EmptyPath();
     } else {
-            DFS(gameBoard, source, boundaries);
+        TrimPath();
-        }
+        if (path.empty())
-        // Create path for food
+            path.push(GetAnyOpenPath());
-        path.push(botPathUnsanitized.top());
-        botPathUnsanitized.pop();
-        while (!botPathUnsanitized.empty()) {
-            sf::Vector2f deltaVector = botPathUnsanitized.top() - path.top();
-            int delta = abs(deltaVector.x) + abs(deltaVector.y);
-            if (delta == 1) {
-                path.push(botPathUnsanitized.top());
-            }
-            botPathUnsanitized.pop();
     }
 }
 
-    void AISnake::BFS(const std::vector< std::vector<char> >& gameBoard, const sf::Vector2f& source, const sf::Vector2f& boundaries) {
+void AISnake::BFS(void) {
     std::queue<sf::Vector2f> search;
-        std::vector<std::vector<bool>> visited(boundaries.y, std::vector<bool> (boundaries.x, false));
+    search.push(g_pEngine->GetHeadLocation());
-        bool foodFound = false;
-        search.push(source);
     while (!search.empty()) {
         sf::Vector2f currentLocation = search.front();
         search.pop();
-            if (foodFound) { break; }
+        if (g_pEngine->gameBoard.at(currentLocation.y).at(currentLocation.x).m_bVisited)
-            if (visited.at(currentLocation.y).at(currentLocation.x)) { continue; }
+            continue;
-            if (gameBoard.at(currentLocation.y).at(currentLocation.x) == 'X') {
-                foodFound = true;
-            }
         botPathUnsanitized.push(currentLocation);
         std::array<sf::Vector2f, 4> localLocations;
         localLocations.fill(currentLocation);
@@ -79,71 +118,234 @@ namespace snakeplusplus
         localLocations[1].x += 1;
         localLocations[2].y -= 1;
         localLocations[3].x -= 1;
-            for (auto i : localLocations) { 
+        for (sf::Vector2f nearby : localLocations) {
             try {
-                    if (gameBoard.at(i.y).at(i.x) == 'X') {
+                GameSpace* space = &g_pEngine->gameBoard.at(nearby.y).at(nearby.x);
-                        botPathUnsanitized.push(i);
+                if (space->m_bFood) {
-                        foodFound = true;
+                    botPathUnsanitized.push(nearby);
+                    return;
                 }
+                if (space->m_bVisited)
+                    continue;
+                if (space->m_bSnake)
+                    continue;
+                search.push(nearby);
             } catch (const std::out_of_range& error) {
                 continue; // Out of bounds
             }
         }
-            for (sf::Vector2f newLocation : localLocations) {
+        g_pEngine->gameBoard.at(currentLocation.y).at(currentLocation.x).m_bVisited = true;
-                try {
-                    if ((!visited.at(newLocation.y).at(newLocation.x))
-                            && (gameBoard.at(newLocation.y).at(newLocation.x) == ' ')) {
-                        search.push(newLocation);
-                    }
-                } catch (const std::out_of_range& error) {
-                    continue; // Out of bounds
-                }
-            }
-            visited.at(currentLocation.y).at(currentLocation.x) = true;
     }
+    pathFailed = true;
 }
 
-    void AISnake::DFS(const std::vector< std::vector<char> >& gameBoard, const sf::Vector2f& source, const sf::Vector2f& boundaries) {
+void AISnake::DFS(void) {
     std::stack<sf::Vector2f> search;
-        std::vector<std::vector<bool>> visited(boundaries.y, std::vector<bool> (boundaries.x, false));
+    search.push(g_pEngine->GetHeadLocation());
-        bool foodFound = false;
-        search.push(source);
     while (!search.empty()) {
         sf::Vector2f currentLocation = search.top();
         search.pop();
-            if (foodFound) { break; }
+        if (g_pEngine->gameBoard.at(currentLocation.y).at(currentLocation.x).m_bVisited)
-            if (visited.at(currentLocation.y).at(currentLocation.x)) { continue; }
+            continue;
-            if (gameBoard.at(currentLocation.y).at(currentLocation.x) == 'X') {
-                foodFound = true;
-            }
         botPathUnsanitized.push(currentLocation);
         std::array<sf::Vector2f, 4> localLocations;
         localLocations.fill(currentLocation);
-            localLocations[0].y += 1;
+        localLocations.at(0).y += 1;
-            localLocations[1].x += 1;
+        localLocations.at(1).x += 1;
-            localLocations[2].y -= 1;
+        localLocations.at(2).y -= 1;
-            localLocations[3].x -= 1;
+        localLocations.at(3).x -= 1;
-            for (auto i : localLocations) { 
+        for (sf::Vector2f nearby : localLocations) {
             try {
-                    if (gameBoard.at(i.y).at(i.x) == 'X') {
+                GameSpace* space = &g_pEngine->gameBoard.at(nearby.y).at(nearby.x);
-                        botPathUnsanitized.push(i);
+                if (space->m_bFood) {
-                        foodFound = true;
+                    botPathUnsanitized.push(nearby);
+                    return;
                 }
+                if (space->m_bVisited)
+                    continue;
+                if (space->m_bSnake)
+                    continue;
+                search.push(nearby);
             } catch (const std::out_of_range& error) {
                 continue; // Out of bounds
             }
         }
-            for (sf::Vector2f newLocation : localLocations) {
+        g_pEngine->gameBoard.at(currentLocation.y).at(currentLocation.x).m_bVisited = true;
-                try {
-                    if ((!visited.at(newLocation.y).at(newLocation.x))
-                            && (gameBoard.at(newLocation.y).at(newLocation.x) == ' ')) {
-                        search.push(newLocation);
     }
+    pathFailed = true;
+}
+
+sf::Vector2f AISnake::GetAnyOpenPath(void) {
+    sf::Vector2f bail;
+    std::array<sf::Vector2f, 4> paths;
+    paths.fill(g_pEngine->GetHeadLocation());
+    paths[0].x -= 1;
+    paths[1].x += 1;
+    paths[2].y -= 1;
+    paths[3].y += 1;
+
+    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;
+            return path;
         } catch (const std::out_of_range& error) {
             continue; // Out of bounds
         }
     }
-            visited.at(currentLocation.y).at(currentLocation.x) = true;
+
+    return bail; // Snake is trapped, give up and die
+}
+
+void AISnake::UnvisitBoard(void) {
+    for (std::vector<GameSpace>& i : g_pEngine->gameBoard)
+        for (GameSpace& j : i)
+            j.m_bVisited = false;
+}
+
+void AISnake::UpdateAverage(const int size) {
+    totalLength += size;
+    amountPlayed += 1;
+    average = (double)totalLength / amountPlayed;
+}
+
+void AISnake::TrimPath(void) {
+    bool reachedSnake = false;
+    path.push(botPathUnsanitized.top()); // Push food location
+    while (!botPathUnsanitized.empty()) {
+        if (!reachedSnake) {
+            sf::Vector2f location = botPathUnsanitized.top();
+            if (g_pEngine->gameBoard[location.y][location.x].m_bSnake)
+                reachedSnake = true;
+            sf::Vector2f deltaVector = location - path.top();
+            int delta = abs(deltaVector.x) + abs(deltaVector.y);
+            if (delta == 1)
+                path.push(location);
+        }
+        botPathUnsanitized.pop();
+    }
+}
+
+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

@@ -3,22 +3,46 @@
 
 #include "common.hpp"
 #include <stack>
-#include <vector>
 #include <SFML/System/Vector2.hpp>
 
-namespace snakeplusplus
-{
 class AISnake {
 public:
     std::stack<sf::Vector2f> path;
-        AISnake();
+    AISnake(void);
-        void GetNewPath(const std::vector< std::vector<char> >& gameBoard, const sf::Vector2f& source, const sf::Vector2f& boundaries, const int snakeSize);
+    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);
+    void ResetPath(void);
+    int amountPlayed = 0;
 private:
+    int totalLength = 0;
+    double average = 0;
+    double thresholdDFS = 0.900;
+    bool pathFailed = false;
+
+    // Generic search algorithms
     std::stack<sf::Vector2f> botPathUnsanitized;
-        void BFS(const std::vector< std::vector<char> >& gameBoard, const sf::Vector2f& source, const sf::Vector2f& boundaries);
+    void BFS(void);
-        void DFS(const std::vector< std::vector<char> >& gameBoard, const sf::Vector2f& source, const sf::Vector2f& boundaries);
+    void DFS(void);
+    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

@@ -2,20 +2,26 @@
 #include <random>
 #include "common.hpp"
 
-namespace snakeplusplus
-{
 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(snakeplusplus::generator);
+    generatedNumber = distribution(generator);
     return generatedNumber;
 }
+
+GameSpace::GameSpace(void) {
+    Reset();
+}
+
+void GameSpace::Reset(void) {
+    m_bFood = 0;
+    m_bSnake = 0;
+    m_bVisited = 0;
 }

src/common.hpp

@@ -1,13 +1,10 @@
 #ifndef COMMON_HPP
 #define COMMON_HPP
 
-namespace snakeplusplus
-{
 void InitializeGenerator(void);
 int GenerateRandomNumber(int generationLimit);
 
-    enum PlayerDirection
+enum PlayerDirection {
-    {
     kNone = 0,
     kLeft = 1,
     kUp = 2,
@@ -15,6 +12,17 @@ namespace snakeplusplus
     kRight = 4
 };
 
-}
+struct 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
+    unsigned char _3 : 1 = 0;
+    unsigned char _4 : 1 = 0;
+    unsigned char _5 : 1 = 0;
+    unsigned char _6 : 1 = 0;
+    unsigned char _7 : 1 = 0;
+    void Reset(void);
+};
 
 #endif

src/gamestate.cpp

@@ -6,144 +6,178 @@
 #include "playerinterface.hpp"
 #include "gamestate.hpp"
 
-namespace snakeplusplus
+GameEngine::GameEngine(void) {
-{
-    GameEngine::GameEngine()
-    {
     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(isBotControlled);
+        graphics.CheckContinue();
+    else
+        bot.AddIteration(player.body.size());
     player.Reset();
-        if (isBotControlled) { 
-            while (!bot.path.empty()) { bot.path.pop(); }
-        }
     PrepareGameBoard();
-        isGameOver = false;
+    state.m_bIsGameOver = false;
+    if (!state.m_bIsBotControlled)
         return;
+    if (!state.m_bSmart) {
+        while (!bot.path.empty())
+            bot.path.pop();
+    }
+    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())
+    while (graphics.IsOpen() || state.m_bNoDisplay) {
-        {
+        if (state.m_bIsGameOver)
-            if (isGameOver) { Reset(); }
+            Reset();
         UpdatePlayerSpeed();
         PlaceNewSnakePart(MovePlayer());
         RegenerateFood();
-            graphics.DisplayGameState(gameBoard);
+        currentScore = player.body.size() * 100;
+        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 newHeadPosition;
-        newHeadPosition.x = player.headLocation.x + player.speed.x;
-        newHeadPosition.y = player.headLocation.y + player.speed.y;
-        return newHeadPosition;
 }
 
-    sf::Vector2f GameEngine::GetGameBoundaries(void)
+
-    {
+sf::Vector2f GameEngine::GetGameBoundaries(void) {
     return graphics.gameBoundaries;
 }
 
-    void GameEngine::PlaceNewSnakePart(sf::Vector2f location)
+PlayerDirection GameEngine::GetCurrentDirection(void) {
-    {
+    if (player.speed.x) {
-        if (!player.speed.x && !player.speed.y) { return; }
+        if (player.speed.x > 0)
-        try 
+            return kRight;
-        {
+        else
-            char* locationState;
+            return kLeft;
-            locationState = &gameBoard.at(location.y).at(location.x);
+    } else {
-            if (*locationState == 'O' && (player.body.size() > 1))
+        if (player.speed.y > 0)
-                isGameOver = true; // Game should end (Snake touching snake)
+            return kDown;
-            *locationState = 'O';
+        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;
+    try {
+        GameSpace* locationState = &gameBoard.at(location.y).at(location.x);
+        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;
         if (playerFood.location != location)
             player.Pop();
+        else {
+            locationState->m_bFood = false;
+            if (state.m_bIsBotControlled)
+                bot.ResetPath();
+        }
     } catch (const std::out_of_range& error) {
-            isGameOver = true; // Snake ran into edge
+        state.m_bIsGameOver = true; // Snake ran into edge
     }
-        return;
 }
 
+
 // Generates new food until not colliding with player
-    void GameEngine::RegenerateFood(void)
+void GameEngine::RegenerateFood(void) {
-    {
+    // Generate a new food location if the current one is occupied
-        sf::Vector2f newLocation = playerFood.location;
+    while (gameBoard.at(playerFood.location.y).at(playerFood.location.x).m_bSnake)
-        bool isUpdated = false;
-        while (gameBoard.at(newLocation.y).at(newLocation.x) == 'O')
-        {
-            isUpdated = true;
         playerFood.GenerateNewFood(GetGameBoundaries());
-            newLocation = playerFood.location;
+
-        }
+    // Update the game board with the new food location
-        if (isUpdated) { 
+    gameBoard.at(playerFood.location.y).at(playerFood.location.x).m_bFood = 1;
-            gameBoard.at(newLocation.y).at(newLocation.x) = 'X';
-        }
-        return;
 }
 
-    void GameEngine::PrepareGameBoard(void)
+
-    {
+void GameEngine::PrepareGameBoard(void) {
+    // Create empty game board
     gameBoard.clear();
     sf::Vector2f boardDimensions = GetGameBoundaries();
-        gameBoard.resize(boardDimensions.y, std::vector<char> (boardDimensions.x, ' '));
+    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);
-            char* locationState = &gameBoard.at(player.headLocation.y).at(player.headLocation.x);
     player.body.push(locationState);
-            *locationState = 'O';
+    locationState->m_bSnake = true;
-        }
+
     // Food setup
     playerFood.GenerateNewFood(boardDimensions);
-        gameBoard.at(playerFood.location.y).at(playerFood.location.x) = 'X';
+    gameBoard.at(playerFood.location.y).at(playerFood.location.x).m_bFood = true;
     return;
 }
 
-    void GameEngine::UpdatePlayerSpeed(void)
+void GameEngine::UpdatePlayerSpeed(void) {
-    {
     PlayerDirection controller;
-        if (isBotControlled) { 
+    if (state.m_bIsBotControlled) { 
-            if (bot.path.empty()) { 
+        if (bot.path.empty())
-                bot.GetNewPath(gameBoard, player.headLocation, GetGameBoundaries(), player.body.size()); 
+            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;
@@ -152,4 +186,3 @@ namespace snakeplusplus
     }
     return;
 }
-}

src/gamestate.hpp

@@ -3,37 +3,49 @@
 #define GAMESTATE_HPP
 
 #include <SFML/Graphics.hpp>
+#include <memory>
 #include "botinterface.hpp"
+#include "common.hpp"
 #include "snake.hpp"
 #include "playerinterface.hpp"
 
-namespace snakeplusplus
-{
 const int kUnitSpeed = 1;
 
-    class GameEngine
+class GameEngine {
-    {
 public:
-        GameEngine();
+    GameEngine(void);
     void Start(void);
     void Reset(void);
     sf::Vector2f GetGameBoundaries(void);
+    struct GameState {
+        unsigned char m_bIsGameOver : 1 = 0;
+        unsigned char m_bIsBotControlled : 1 = 0;
+        unsigned char m_bNoDisplay : 1 = 0;
+        unsigned char m_bSmart : 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:
-        std::vector< std::vector<char> > gameBoard;
     PlayerOutput graphics;
     Snake player;
     Food playerFood;
     AISnake bot;
-        bool isGameOver = 0;
-        bool isBotControlled = 1;
-        void DisplayEndScreen(void);
     void Loop(void);
     sf::Vector2f MovePlayer(void);
     void PlaceNewSnakePart(sf::Vector2f location);
     void RegenerateFood(void);
     void PrepareGameBoard(void);
-        void UpdatePlayerSpeed();
+    void UpdatePlayerSpeed(void);
 };
-}
+
+inline std::unique_ptr<GameEngine> g_pEngine;
 
 #endif

src/main.cpp

@@ -1,8 +1,48 @@
 #include "gamestate.hpp"
+#include <memory>
+#include <string>
+#include <vector>
+#include <iostream>
 
-int main(void)
+void Help(void) {
-{
+    std::cout << "Usage: snakeplusplus [OPTIONS]" << std::endl;
-    snakeplusplus::GameEngine game;
+    std::cout << "Options:" << std::endl;
-    game.Start();
+    std::cout << "\t--server\tRun snake in server mode (also sets --bot)" << std::endl;
+    std::cout << "\t--auto\t\tControl snake using a bot or AI" << std::endl;
+    std::cout << "\t-h, --help\tPrint this help message and exit" << std::endl;
+    std::cout << std::endl;
+    std::cout << "Autoplay options (requires --auto):" << std::endl;
+    std::cout << "\t--dumb\t\tPlays using basic search algorithms BFS and DFS" << std::endl;
+    std::cout << "\t--smart\t\tTrains an algorithm using unsupervised learning" << std::endl;
+    std::cout << std::endl;
+}
+
+int main(int argc, char* argv[]) {
+    std::vector<std::string> args(argv, argv + argc);
+    g_pEngine = std::make_unique<GameEngine>();
+    for (int i = 1; i < args.size(); ++i) {
+        if (args[i].compare("--server") == 0) {
+            g_pEngine->state.m_bNoDisplay = true;
+            g_pEngine->state.m_bIsBotControlled = true;
+            std::cout << "[LOG - Main] Disabling display" << std::endl;
+        } 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;
+        } else {
+            std::cout << "[LOG - Main] Argument `" << args[i] << "` unrecognized, printing help and exiting..."<< std::endl;
+            Help();
+            return 1;
+        }
+    }
+    g_pEngine->Start();
     return 0;
 }

src/playerinterface.cpp

@@ -2,32 +2,29 @@
 #include <SFML/System/Vector2.hpp>
 #include <SFML/Window/Keyboard.hpp>
 
-namespace snakeplusplus 
+PlayerDirection GetPlayerInput(void) {
-{
+    if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left) ||
-    PlayerDirection GetPlayerInput(void)
+            (sf::Keyboard::isKeyPressed(sf::Keyboard::A)))
-    {
-        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left) 
-                || 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;
-        return gameWindow.isOpen();
 }
 
-    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;
@@ -38,26 +35,23 @@ namespace snakeplusplus
     return;
 }
 
-    void PlayerOutput::CheckContinue(bool isBotControlled)
+void PlayerOutput::CheckContinue(void) {
-    {
-        if (isBotControlled) { return; }
     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;
@@ -71,75 +65,85 @@ namespace snakeplusplus
     return;
 }
 
-    void PlayerOutput::DisplayGameState(std::vector< std::vector<char> >& gameBoard)
+void PlayerOutput::DisplayScore(int score) {
-    {
+    sf::Vector2f textPosition(gameBoundaries);
+    textPosition.x = textPosition.x / 2;
+    textPosition.y = textPosition.y / 2;
+    sf::Font font;
+    font.loadFromFile("Arial.ttf");
+    std::string text = "Score: " + std::to_string(score);
+    sf::Text ScoreText(text, font);
+    ScoreText.setPosition(textPosition);
+    gameWindow.draw(ScoreText);
+}
+
+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)
-            {
-                letterOnBoard = &gameBoard.at(y).at(x);
-                switch (*letterOnBoard)
-                {
-                    case 'O':
                 DrawSnake(sf::Vector2f(x, y));
-                        break;
+            else if (gameBoard.at(y).at(x).m_bFood)
-                    case 'X':
                 DrawFood(sf::Vector2f(x,y));
-                        break;
+            else
-                    default:
                 DrawEmpty(sf::Vector2f(x,y));
-                        break;
-                }
         }
     }
+    DisplayScore(score);
     gameWindow.display();
     sf::sleep(delay);
     return;
 }
 
-    void PlayerOutput::StartGameWindow(void)
+void PlayerOutput::StartGameWindow(void) {
-    {
     gameWindow.create(gameVideoSettings, "SnakePlusPlus");
     isWindowAlive = true;
-        return;
 }
 
-    void PlayerOutput::CheckWindowEvents(void)
+void PlayerOutput::SetShowGame(bool isShowing) {
-    {
+    if (isShowing)
-        while (gameWindow.pollEvent(event))
+        delay = sf::milliseconds(5);
-        {
+    else
-            if ((event.type == sf::Event::Closed)
+        delay = sf::milliseconds(0);
-                    || (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)))
+}
+
+void PlayerOutput::CheckWindowEvents(void) {
+    while (gameWindow.pollEvent(event)) {
+        if ((event.type == sf::Event::Closed) || 
+                (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))) {
             gameWindow.close();
+            isWindowAlive = false;
+        }
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Equal)) { 
+            if (delay > sf::milliseconds(16)) { continue; }
+            delay += sf::milliseconds(1);
+        }
+        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Hyphen)) { 
+            if (delay == sf::milliseconds(0)) { continue; }
+            delay -= sf::milliseconds(1);
+        }
     }
 }
 
-    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

@@ -6,19 +6,18 @@
 
 const int kGridSize = 25;
 
-namespace snakeplusplus
-{
 PlayerDirection GetPlayerInput(void);
 
-    class PlayerOutput 
+class PlayerOutput {
-    {
 public:
     sf::Vector2f gameBoundaries;
     PlayerOutput(void);
     bool IsOpen(void);
-        void CheckContinue(bool isBotControlled);
+    void CheckContinue(void);
-        void DisplayGameState(std::vector< std::vector<char> >& gameBoard);
+    void DisplayGameState(std::vector< std::vector<GameSpace> >& gameBoard, int score);
+    void DisplayScore(int score);
     void StartGameWindow(void);
+    void SetShowGame(bool isShowing);
 private:
     void CheckWindowEvents(void);
     void DisplayEndScreen(void);
@@ -29,9 +28,8 @@ namespace snakeplusplus
     sf::VideoMode gameVideoSettings;
     sf::RectangleShape drawObject;
     sf::Event event;
-        bool isWindowAlive;
+    bool isWindowAlive = false;
-        sf::Time delay = sf::milliseconds(15);
+    sf::Time delay = sf::milliseconds(12);
 };
-}
 
 #endif

src/snake.cpp

@@ -4,28 +4,23 @@
 #include "common.hpp"
 #include "snake.hpp"
  
-namespace snakeplusplus
+void Snake::Pop(void) {
-{
+    body.front()->m_bSnake = false;
-    void Snake::Pop(void)
-    {
-        *(body.front()) = ' ';
     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

@@ -4,26 +4,21 @@
 
 #include <SFML/System/Vector2.hpp>
 #include <queue>
+#include "common.hpp"
 
-namespace snakeplusplus
+struct Snake {
-{
-    struct Snake
-    {
 public:
     sf::Vector2f headLocation;
     sf::Vector2f speed;
-        std::queue<char*> body;
+    std::queue<GameSpace*> body;
     void Pop(void);
     void Reset(void);
 };
 
-    struct Food
+struct Food {
-    {
 public:
     sf::Vector2f location;
-        char* food;
     void GenerateNewFood(sf::Vector2f boundaries);
 };
-}
 
 #endif