Menus ang game states

Makefile

 INCLUDES=-Iinclude -Ipge/include
 ifeq ($(OS),Windows_NT)
 	LIBRARIES=-luser32 -lgdi32 -lopengl32 -lgdiplus -lwinmm
-	EXECUTABLE=debuggers.exe
+	EXECUTABLE=bin/debuggers.exe
 	PACKER=packer/packer.exe
 ifneq ($(DEBUG),1)
 	LDFLAGS+=--machine=windows
 	MAKE=mingw32-make
 else
 	LIBRARIES=-lX11 -lGL -lpthread -lpng -lasound
-	EXECUTABLE=debuggers
+	EXECUTABLE=bin/debuggers
 	PACKER=packer/packer
 	CC=gcc
 	CPP=g++
 SPRITES=$(IMAGES:.png=.pgs)
 RESOURCES=$(SPRITES) $(wildcard res/*.wav) src/programmer.cpp
 
-PACK=debuggers.pgp
+PACK=bin/debuggers.pgp
 
 all: $(SOURCES) $(PACK) $(EXECUTABLE)
 

TODO.md

  # TODO
- - [ ] Main menu
- - [ ] Pause (ESC) menu
- - [ ] Play as bug gamemode
+ - [X] Main menu
+ - [X] Pause (ESC) menu
+ - [ ] Help screen
 
- - [ ] Bugs only catchable by 2 programmers
- - [ ] Bugs only catchable with debugger
- - [ ] Bugs only catchable with unit tests
- - [ ] Bugs immune to debugger
- - [ ] Bugs immune to unit tests
- - [ ] Not bug - a feature
- - [ ] Reduce programmers spawn rate (maybe cubic function?)
+ - [ ] ? Bugs only catchable by 2 programmers
+ - [ ] ? Bugs only catchable with debugger
+ - [ ] ? Bugs only catchable with unit tests
+ - [ ] ? Bugs immune to debugger
+ - [ ] ? Bugs immune to unit tests
+ - [ ] ? Not bug - a feature
+ - [X] Reduce programmers spawn rate (maybe cubic function?)
  - [ ] Add obstacles to prevent flying across the screen
    - [ ] Edits by customer
    - [ ] QA engineers

include/debuggers.h

 #include "programmer.h"
 
 #include <chrono>
+#include <list>
 #include <map>
 #include <random>
 #include <string>
 #include <vector>
 
 namespace pabloader {
+enum GameState {
+    STATE_MAIN_MENU,
+    STATE_GAME,
+    STATE_PAUSE_MENU,
+    STATE_GAME_OVER,
+    STATE_HELP,
+    STATE_QUIT
+};
+
 class Debuggers : public olc::PixelGameEngine {
 private:
-    std::vector<Programmer*> programmers;
-    std::vector<Bonus*> bonuses;
+    std::list<Programmer*> programmers;
+    std::list<Bonus*> bonuses;
 
     std::map<BonusType, uint32_t> bonusesCatched;
 
 
     uint8_t linesOfCode = 5;
     uint16_t totalLines;
-    std::vector<std::string> sourceCode;
-    std::random_device rd;
+    std::list<std::string> originalSourceCode;
+    std::list<std::string> sourceCode;
+
+    GameState state = STATE_MAIN_MENU;
+
     std::mt19937 generator;
 
 public:
     Debuggers()
-        : generator(rd())
+        : generator(std::chrono::system_clock::now().time_since_epoch().count())
     {
         sAppName = "Debuggers";
     }
     bool OnUserCreate() override;
     bool OnUserUpdate(float fElapsedTime) override;
     bool OnUserDestroy() override;
-    int GameScreenHeight() { return ScreenHeight() - linesOfCode * 10; };
+    int GameScreenHeight() { return ScreenHeight() - linesOfCode * 10; }
+    GameState GetState() { return state; }
 
     template <typename T>
     T GetRandom(T from = 0, T to = 1);
 
 private:
+    void ResetGame();
+    void SwitchState(GameState newState);
+    void DrawMenu();
+
+    void SpawnPlayer();
     void SpawnProgrammer();
     void SpawnBug();
     void SpawnBonus();
     Bug* CreateBug();
     Bonus* CreateBonus();
-    bool GameOver();
+
+private: // Gamemodes
+    bool MainMenu(float dt);
+    bool GamePlay(float dt);
+    bool PauseMenu(float dt);
+    bool GameOver(float dt);
+    bool HelpMenu(float dt);
 
 public:
-    std::vector<Bug*> bugs;
+    std::list<Bug*> bugs;
 
     olc::ResourcePack pack;
 
     int bugFallSample;
     int bugCatchSample;
 
-    const int gravity = 30;
+    const int gravity = 25;
 #ifdef _DEBUG
-    bool debug = true;
+    bool debug = false;
 #endif
 };
 }

include/programmer.h

     bool IsOnGround() { return onGround; }
     uint8_t GetSkin() { return tile.x; }
     void UpgradeLevel() { tile.x = std::min(tile.x + 1, tileDim.x - 1); }
+
+private:
+#ifdef _DEBUG
+    olc::vf2d target;
+#endif
 };
 }
 

pge/include/olcPGE_Common.h

         NO_FILE = -1,
     };
     std::wstring ConvertS2W(std::string s);
+
+    
+	template <class T>
+	struct v2d_generic
+	{
+		T x = 0;
+		T y = 0;
+
+		inline v2d_generic() : x(0), y(0)                        {                                                      }
+		inline v2d_generic(T _x, T _y) : x(_x), y(_y)            {                                                      }
+		inline v2d_generic(const v2d_generic& v) : x(v.x), y(v.y){                                                      }
+		inline T mag()                                           { return sqrt(x * x + y * y);                          }
+		inline v2d_generic  norm()                               { T r = 1 / mag(); return v2d_generic(x*r, y*r);       }
+		inline v2d_generic  perp()                               { return v2d_generic(-y, x);                           }
+		inline T dot(const v2d_generic& rhs)                     { return this->x * rhs.x + this->y * rhs.y;            }
+		inline T cross(const v2d_generic& rhs)                   { return this->x * rhs.y - this->y * rhs.x;            }
+		inline v2d_generic  operator +  (const v2d_generic& rhs) const { return v2d_generic(this->x + rhs.x, this->y + rhs.y);}
+		inline v2d_generic  operator -  (const v2d_generic& rhs) const { return v2d_generic(this->x - rhs.x, this->y - rhs.y);}
+		inline v2d_generic  operator *  (const T& rhs)           const { return v2d_generic(this->x * rhs, this->y * rhs);    }
+		inline v2d_generic  operator /  (const T& rhs)           const { return v2d_generic(this->x / rhs, this->y / rhs);    }
+		inline v2d_generic& operator += (const v2d_generic& rhs) { this->x += rhs.x; this->y += rhs.y; return *this;    }
+		inline v2d_generic& operator -= (const v2d_generic& rhs) { this->x -= rhs.x; this->y -= rhs.y; return *this;    }
+		inline v2d_generic& operator *= (const T& rhs)           { this->x *= rhs; this->y *= rhs; return *this;        }
+		inline v2d_generic& operator /= (const T& rhs)           { this->x /= rhs; this->y /= rhs; return *this;        }
+		inline T& operator [] (std::size_t i)                    { return *((T*)this + i);	   /* <-- D'oh :( */        }
+	};
+
+	template<class T> inline v2d_generic<T> operator * (const float& lhs, const v2d_generic<T>& rhs) { return v2d_generic<T>(lhs * rhs.x, lhs * rhs.y); }
+	template<class T> inline v2d_generic<T> operator * (const double& lhs, const v2d_generic<T>& rhs){ return v2d_generic<T>(lhs * rhs.x, lhs * rhs.y); }
+	template<class T> inline v2d_generic<T> operator * (const int& lhs, const v2d_generic<T>& rhs)   { return v2d_generic<T>(lhs * rhs.x, lhs * rhs.y); }
+	template<class T> inline v2d_generic<T> operator / (const float& lhs, const v2d_generic<T>& rhs) { return v2d_generic<T>(lhs / rhs.x, lhs / rhs.y); }
+	template<class T> inline v2d_generic<T> operator / (const double& lhs, const v2d_generic<T>& rhs){ return v2d_generic<T>(lhs / rhs.x, lhs / rhs.y); }
+	template<class T> inline v2d_generic<T> operator / (const int& lhs, const v2d_generic<T>& rhs)   { return v2d_generic<T>(lhs / rhs.x, lhs / rhs.y); }
+
+	typedef v2d_generic<int> vi2d;
+	typedef v2d_generic<float> vf2d;
+	typedef v2d_generic<double> vd2d;
 }
 
 #endif

pge/include/olcPixelGameEngine.h

 
 namespace olc // All OneLoneCoder stuff will now exist in the "olc" namespace
 {
-	template <class T>
-	struct v2d_generic
-	{
-		T x = 0;
-		T y = 0;
-
-		inline v2d_generic() : x(0), y(0)                        {                                                      }
-		inline v2d_generic(T _x, T _y) : x(_x), y(_y)            {                                                      }
-		inline v2d_generic(const v2d_generic& v) : x(v.x), y(v.y){                                                      }
-		inline T mag()                                           { return sqrt(x * x + y * y);                          }
-		inline v2d_generic  norm()                               { T r = 1 / mag(); return v2d_generic(x*r, y*r);       }
-		inline v2d_generic  perp()                               { return v2d_generic(-y, x);                           }
-		inline T dot(const v2d_generic& rhs)                     { return this->x * rhs.x + this->y * rhs.y;            }
-		inline T cross(const v2d_generic& rhs)                   { return this->x * rhs.y - this->y * rhs.x;            }
-		inline v2d_generic  operator +  (const v2d_generic& rhs) const { return v2d_generic(this->x + rhs.x, this->y + rhs.y);}
-		inline v2d_generic  operator -  (const v2d_generic& rhs) const { return v2d_generic(this->x - rhs.x, this->y - rhs.y);}
-		inline v2d_generic  operator *  (const T& rhs)           const { return v2d_generic(this->x * rhs, this->y * rhs);    }
-		inline v2d_generic  operator /  (const T& rhs)           const { return v2d_generic(this->x / rhs, this->y / rhs);    }
-		inline v2d_generic& operator += (const v2d_generic& rhs) { this->x += rhs.x; this->y += rhs.y; return *this;    }
-		inline v2d_generic& operator -= (const v2d_generic& rhs) { this->x -= rhs.x; this->y -= rhs.y; return *this;    }
-		inline v2d_generic& operator *= (const T& rhs)           { this->x *= rhs; this->y *= rhs; return *this;        }
-		inline v2d_generic& operator /= (const T& rhs)           { this->x /= rhs; this->y /= rhs; return *this;        }
-		inline T& operator [] (std::size_t i)                    { return *((T*)this + i);	   /* <-- D'oh :( */        }
-	};
-
-	template<class T> inline v2d_generic<T> operator * (const float& lhs, const v2d_generic<T>& rhs) { return v2d_generic<T>(lhs * rhs.x, lhs * rhs.y); }
-	template<class T> inline v2d_generic<T> operator * (const double& lhs, const v2d_generic<T>& rhs){ return v2d_generic<T>(lhs * rhs.x, lhs * rhs.y); }
-	template<class T> inline v2d_generic<T> operator * (const int& lhs, const v2d_generic<T>& rhs)   { return v2d_generic<T>(lhs * rhs.x, lhs * rhs.y); }
-	template<class T> inline v2d_generic<T> operator / (const float& lhs, const v2d_generic<T>& rhs) { return v2d_generic<T>(lhs / rhs.x, lhs / rhs.y); }
-	template<class T> inline v2d_generic<T> operator / (const double& lhs, const v2d_generic<T>& rhs){ return v2d_generic<T>(lhs / rhs.x, lhs / rhs.y); }
-	template<class T> inline v2d_generic<T> operator / (const int& lhs, const v2d_generic<T>& rhs)   { return v2d_generic<T>(lhs / rhs.x, lhs / rhs.y); }
-
-	typedef v2d_generic<int> vi2d;
-	typedef v2d_generic<float> vf2d;
-	typedef v2d_generic<double> vd2d;
-
-	//=============================================================
-
 	struct HWButton
 	{
 		bool bPressed = false;	// Set once during the frame the event occurs

src/debuggers.cpp

 
 bool Debuggers::OnUserCreate()
 {
-    SetPixelMode(olc::Pixel::MASK);
     std::srand(std::time(0));
 
     if (!olc::SOUND::InitialiseAudio()) {
     std::string line;
     while (std::getline(is, line)) {
         if (!rtrim(line).empty())
-            sourceCode.push_back(line);
+            originalSourceCode.push_back(line);
     }
 
-    totalLines = sourceCode.size();
+    totalLines = originalSourceCode.size();
 
     // Free Memory
     pack.ClearPack();
 
     // Creating entities
 
-    auto player = new Player(this);
-    programmers.push_back(player);
+    ResetGame();
+    SwitchState(STATE_MAIN_MENU);
 
     return true;
 }
 
 bool Debuggers::OnUserUpdate(float fElapsedTime)
 {
-    if (!IsFocused())
-        return true;
-
-    if (sourceCode.size() == 0) {
-        return GameOver();
-    }
-
-    DrawSprite(0, 0, &backgroundSprite);
-
-    uint32_t bugsSize = bugs.size();
-    auto aliveBugs = std::count_if(bugs.begin(), bugs.end(), [](Bug* bug) { return bug->IsActive() && bug->IsAlive(); });
-
-    Programmer* player = programmers.at(0);
-
-    for (auto bug : bugs) {
-        if (bug->IsActive()) {
-            bug->Update(fElapsedTime);
-            bug->Draw();
-            for (auto& programmer : programmers) {
-                if (programmer->Collides(bug)) {
-                    bugsCatched++;
-                    if (programmer == player) {
-                        bugsCatchedByPlayer++;
-                    }
-                    bug->Kill();
-                    olc::SOUND::PlaySample(bugCatchSample);
-                    SpawnBug();
-                }
-            }
-        } else if (bug->IsAlive()) {
-            bugsMissed++;
-            sourceCode.erase(sourceCode.begin());
-
-            SpawnBug();
-            olc::SOUND::PlaySample(bugFallSample);
-        }
-    }
-
-    for (auto& bonus : bonuses) {
-        if (bonus->IsActive()) {
-            bonus->Update(fElapsedTime);
-            bonus->Draw();
-            if (player->Collides(bonus)) {
-                auto type = bonus->GetType();
-                if (type == BONUS_DOCUMENTATION) {
-                    if (aliveBugs > 1) {
-                        for (auto& bug : bugs) {
-                            if (bug->IsAlive() && bug->IsActive()) {
-                                bug->Kill();
-                                break;
-                            }
-                        }
-                    }
-                } else {
-                    bonusesCatched[type]++;
-                }
-                bonus->Kill();
-                // TODO play pickup sound
-            }
-        } else {
-            bonus->Kill();
-        }
-    }
-
-    linesOfCode = (sourceCode.size() * 4 / totalLines) + 1;
-
-    for (auto it = programmers.rbegin(); it != programmers.rend(); it++) {
-        auto& programmer = *it;
-        programmer->Think();
-        programmer->Update(fElapsedTime);
-        programmer->Draw();
-    }
-
-    if (bugsSize == 0 && player->IsOnGround()) {
-        SpawnBug();
-    }
-
-    auto programmersSize = programmers.size();
-    if (bugsCatchedByPlayer >= 15 * programmersSize * programmersSize && player->GetSkin() < programmersSize) {
-        player->UpgradeLevel();
-        SpawnBug();
-        SpawnProgrammer();
-    }
-
-    if (bugsCatched > 10 * bugsSize) {
-        SpawnBug();
-    }
-
-    if (GetRandom<float>() < 0.01 * fElapsedTime) {
-        SpawnBonus();
-    }
-
 #ifdef _DEBUG
     if (debug) {
-        DrawString(1, 37, "Bg: " + std::to_string(bugs.size()) + " Ab: " + std::to_string(aliveBugs));
-        DrawString(1, 46, "Ps: " + std::to_string(programmers.size()) + " Bn: " + std::to_string(bonuses.size()));
-        DrawString(1, 55, "Cp: " + std::to_string(bugsCatchedByPlayer));
-        DrawString(1, 64, "DBG: " + std::to_string(bonusesCatched[BONUS_DEBUGGER]));
-        DrawString(1, 73, "UTS: " + std::to_string(bonusesCatched[BONUS_UNIT_TEST]));
-
         if (GetKey(olc::B).bPressed) {
             SpawnBug();
         }
         debug = !debug;
     }
 #endif
-    DrawString(1, 1, "A,S,D - move; SPACE - jump", olc::CYAN);
-    DrawString(1, 10, "Don't let the bugs destroy your code!", olc::YELLOW);
-    DrawString(1, 19, "Bugs catched: " + std::to_string(bugsCatched));
-    DrawString(1, 28, "Bugs missed: " + std::to_string(bugsMissed));
-
-    int y = GameScreenHeight();
-    FillRect(0, y - 1, ScreenWidth(), ScreenHeight() - y + 1, olc::VERY_DARK_GREY);
-
-    for (auto& line : sourceCode) {
-        DrawString(1, y, line);
-        y += 10;
-        if (y >= ScreenHeight())
-            break;
+    switch (state) {
+    case STATE_GAME:
+    case STATE_MAIN_MENU:
+        return GamePlay(fElapsedTime);
+    case STATE_PAUSE_MENU:
+        return PauseMenu(fElapsedTime);
+    case STATE_GAME_OVER:
+        return GameOver(fElapsedTime);
+    default:
+        return false;
     }
+}
 
-    return true;
+void Debuggers::DrawMenu()
+{
+    SetPixelMode(olc::Pixel::ALPHA);
+    FillRect(0, 0, ScreenWidth(), ScreenHeight(), { 0, 0, 0, 160 });
+    SetPixelMode(olc::Pixel::NORMAL);
+
+    DrawString(ScreenWidth() / 2 - 144, 32, "DEBUGGERS", olc::YELLOW, 4);
+    DrawString(ScreenWidth() - 128, 64, "by Pabloader");
+    DrawString(ScreenWidth() - 17 * 8 - 2, ScreenHeight() - 10, "OLC Code Jam 2019");
+
+    std::string resumeText = state == STATE_PAUSE_MENU ? "continue" : "start";
+
+    DrawString(ScreenWidth() / 2 - 144, 100, "SPACE to " + resumeText + " game");
+    DrawString(ScreenWidth() / 2 - 144, 116, "H to view help");
+    DrawString(ScreenWidth() / 2 - 144, 132, "X to quit");
+
+    if (GetKey(olc::SPACE).bPressed || (GetKey(olc::ESCAPE).bPressed && state == STATE_PAUSE_MENU)) {
+        SwitchState(STATE_GAME);
+    }
+
+    if (GetKey(olc::H).bPressed) {
+        SwitchState(STATE_HELP);
+    }
+
+    if (GetKey(olc::X).bPressed) {
+        SwitchState(STATE_QUIT);
+    }
+}
+
+void Debuggers::SwitchState(GameState newState)
+{
+    switch (newState) {
+    case STATE_GAME:
+        if (state == STATE_MAIN_MENU || state == STATE_GAME_OVER) {
+            ResetGame();
+            SpawnPlayer();
+        }
+        break;
+    case STATE_MAIN_MENU:
+        ResetGame();
+        SpawnProgrammer();
+        break;
+    default:
+        break;
+    }
+
+    state = newState;
 }
 
-bool Debuggers::GameOver()
+void Debuggers::ResetGame()
 {
-    DrawSprite(0, 0, &backgroundSprite);
-    DrawString(ScreenWidth() / 2 - 143, ScreenHeight() / 2 - 15, "GAME OVER", olc::BLACK, 4);
-    DrawString(ScreenWidth() / 2 - 144, ScreenHeight() / 2 - 16, "GAME OVER", olc::RED, 4);
+    for (auto& i : programmers) {
+        delete i;
+    }
+    programmers.clear();
 
-    DrawString(ScreenWidth() / 2 - 144, ScreenHeight() / 2 + 16, "Bugs catched: " + std::to_string(bugsCatched), olc::CYAN, 2);
+    for (auto& i : bugs) {
+        i->Kill();
+    }
 
-    return true;
+    for (auto& i : bonuses) {
+        i->Kill();
+    }
+
+    bonusesCatched.clear();
+    bugsCatched = 0;
+    bugsCatchedByPlayer = 0;
+    bugsMissed = 0;
+    sourceCode = originalSourceCode;
 }
 
 void Debuggers::SpawnBug()
     bonus->ResetPosition();
 }
 
+void Debuggers::SpawnPlayer()
+{
+    auto programmer = new Player(this);
+    programmers.push_front(programmer);
+}
+
 void Debuggers::SpawnProgrammer()
 {
     auto programmer = new Programmer(this);

src/debuggers_states.cpp

+#include "debuggers.h"
+#include <algorithm>
+#include <cmath>
+#include <ctime>
+#include <iostream>
+#include <random>
+
+namespace pabloader {
+
+bool Debuggers::GamePlay(float fElapsedTime)
+{
+    if (state == STATE_GAME) {
+        if (!IsFocused() || GetKey(olc::ESCAPE).bPressed) {
+            SwitchState(STATE_PAUSE_MENU);
+            return true;
+        }
+
+        if (sourceCode.size() == 0) {
+            SwitchState(STATE_GAME_OVER);
+            return true;
+        }
+    }
+
+    DrawSprite(0, 0, &backgroundSprite);
+
+    uint32_t bugsSize = bugs.size();
+    auto aliveBugs = std::count_if(bugs.begin(), bugs.end(), [](Bug* bug) { return bug->IsActive() && bug->IsAlive(); });
+
+    Programmer* player = programmers.front();
+
+    for (auto& bug : bugs) {
+        if (bug->IsActive()) {
+            bug->Update(fElapsedTime);
+            bug->Draw();
+            for (auto& programmer : programmers) {
+                if (programmer->Collides(bug)) {
+                    bugsCatched++;
+                    if (programmer == player) {
+                        bugsCatchedByPlayer++;
+                    }
+                    bug->Kill();
+                    if (state == STATE_GAME)
+                        olc::SOUND::PlaySample(bugCatchSample);
+                    SpawnBug();
+                }
+            }
+        } else if (bug->IsAlive()) {
+            bugsMissed++;
+            SpawnBug();
+            if (state == STATE_GAME) {
+                sourceCode.erase(sourceCode.begin());
+                olc::SOUND::PlaySample(bugFallSample);
+            }
+        }
+    }
+
+    for (auto& bonus : bonuses) {
+        if (bonus->IsActive()) {
+            bonus->Update(fElapsedTime);
+            bonus->Draw();
+            if (player->Collides(bonus)) {
+                auto type = bonus->GetType();
+                if (type == BONUS_DOCUMENTATION) {
+                    if (aliveBugs > 1) {
+                        for (auto& bug : bugs) {
+                            if (bug->IsAlive() && bug->IsActive()) {
+                                bug->Kill();
+                                break;
+                            }
+                        }
+                    }
+                } else {
+                    bonusesCatched[type]++;
+                }
+                bonus->Kill();
+                // TODO play pickup sound
+            }
+        } else {
+            bonus->Kill();
+        }
+    }
+
+    linesOfCode = (sourceCode.size() * 4 / totalLines) + 1;
+
+    for (auto it = programmers.rbegin(); it != programmers.rend(); it++) {
+        auto& programmer = *it;
+        programmer->Think();
+        programmer->Update(fElapsedTime);
+        programmer->Draw();
+    }
+
+    if (aliveBugs == 0 && player->IsOnGround()) {
+        SpawnBug();
+    }
+
+    auto programmersSize = programmers.size();
+    if (bugsCatchedByPlayer >= 15 * programmersSize * programmersSize * programmersSize && player->GetSkin() < programmersSize) {
+        player->UpgradeLevel();
+        SpawnBug();
+        SpawnProgrammer();
+    }
+
+    if (bugsCatched > 10 * bugsSize) {
+        SpawnBug();
+    }
+
+    if (GetRandom<float>() < 0.01 * fElapsedTime) {
+        SpawnBonus();
+    }
+
+#ifdef _DEBUG
+    if (debug) {
+        DrawString(1, 37, "Bg: " + std::to_string(bugs.size()) + " Ab: " + std::to_string(aliveBugs));
+        DrawString(1, 46, "Ps: " + std::to_string(programmers.size()) + " Bn: " + std::to_string(bonuses.size()));
+        DrawString(1, 55, "Cp: " + std::to_string(bugsCatchedByPlayer));
+        DrawString(1, 64, "DBG: " + std::to_string(bonusesCatched[BONUS_DEBUGGER]));
+        DrawString(1, 73, "UTS: " + std::to_string(bonusesCatched[BONUS_UNIT_TEST]));
+    }
+#endif
+    if (state == STATE_GAME) {
+        DrawString(1, 1, "A,S,D - move; SPACE - jump", olc::CYAN);
+        DrawString(1, 10, "Don't let the bugs destroy your code!", olc::YELLOW);
+        DrawString(1, 19, "Bugs catched: " + std::to_string(bugsCatched));
+        DrawString(1, 28, "Bugs missed: " + std::to_string(bugsMissed));
+    }
+
+    int y = GameScreenHeight();
+    FillRect(0, y - 1, ScreenWidth(), ScreenHeight() - y + 1, olc::VERY_DARK_GREY);
+
+    for (auto& line : sourceCode) {
+        DrawString(1, y, line);
+        y += 10;
+        if (y >= ScreenHeight())
+            break;
+    }
+
+    if (state == STATE_MAIN_MENU) {
+        DrawMenu();
+    }
+
+    return true;
+}
+
+bool Debuggers::PauseMenu(float fElapsedTime)
+{
+    DrawSprite(0, 0, &backgroundSprite);
+
+    for (auto& bug : bugs) {
+        if (bug->IsActive() && bug->IsAlive()) {
+            bug->Draw();
+        }
+    }
+
+    for (auto& bonus : bonuses) {
+        if (bonus->IsActive()) {
+            bonus->Draw();
+        }
+    }
+
+    for (auto it = programmers.rbegin(); it != programmers.rend(); it++) {
+        auto& programmer = *it;
+        programmer->Draw();
+    }
+
+    int y = GameScreenHeight();
+    FillRect(0, y - 1, ScreenWidth(), ScreenHeight() - y + 1, olc::VERY_DARK_GREY);
+
+    for (auto& line : sourceCode) {
+        DrawString(1, y, line);
+        y += 10;
+        if (y >= ScreenHeight())
+            break;
+    }
+
+    DrawMenu();
+
+    return true;
+}
+
+bool Debuggers::GameOver(float dt)
+{
+    DrawSprite(0, 0, &backgroundSprite);
+    DrawString(ScreenWidth() / 2 - 143, ScreenHeight() / 2 - 15, "GAME OVER", olc::BLACK, 4);
+    DrawString(ScreenWidth() / 2 - 144, ScreenHeight() / 2 - 16, "GAME OVER", olc::RED, 4);
+
+    DrawString(ScreenWidth() / 2 - 144, ScreenHeight() / 2 + 16, "Bugs catched: " + std::to_string(bugsCatched), olc::CYAN, 2);
+    DrawString(ScreenWidth() / 2 - 144, ScreenHeight() / 2 + 34, "Press SPACE to continue");
+
+    if (GetKey(olc::SPACE).bPressed) {
+        SwitchState(STATE_MAIN_MENU);
+    }
+
+    return true;
+}
+}

src/entity.cpp

 void Entity::Update(float dt)
 {
     pos += vel * dt;
-    pos.y += game->gravity * dt;
+    vel.y += game->gravity * dt;
 
     rotation += rotationSpeed * dt;
 
         game->DrawRect(pos.x - size.x / 2, pos.y - size.y / 2, size.x, size.y, DEBUG_COLOR);
     }
 #endif
+    game->SetPixelMode(olc::Pixel::MASK);
     olc::GFX2D::DrawPartialSprite(sprite, tile.x * size.x, tile.y * size.y, size.x, size.y, transform, true);
+    game->SetPixelMode(olc::Pixel::NORMAL);
 }
 
 bool Entity::IsActive()
 {
     return pos.x > -size.x / 2 && pos.y > -size.y
         && pos.x < game->ScreenWidth() + size.x / 2
-        && pos.x < game->ScreenHeight() + size.y / 2;
+        && pos.y < game->ScreenHeight() + size.y / 2;
 }
 
 bool Entity::IsAlive()

src/programmer.cpp

 {
     Bug* closest = nullptr;
     float dist = 1e100;
-    for (auto bug : game->bugs) {
+    for (auto& bug : game->bugs) {
         float d = bug->Dist(this);
         if (d < dist && bug->IsInScreen() && bug->IsAlive()) {
             dist = d;
     }
 
     if (closest != nullptr) {
+#ifdef _DEBUG
+        target.x = closest->GetX();
+        target.y = closest->GetY();
+#endif
         doJump = closest->GetY() < pos.y;
         moveDown = closest->GetY() > pos.y;
         walkLeft = closest->GetX() < pos.x;
         walkRight = closest->GetX() > pos.x;
     } else {
+#ifdef _DEBUG
+        target.x = 0;
+        target.y = 0;
+#endif
         doJump = false;
         walkLeft = false;
         walkRight = false;
     if (pos.x > game->ScreenWidth() - size.x / 2) {
         vel.x *= -0.3;
         pos.x = game->ScreenWidth() - size.x / 2;
-        olc::SOUND::PlaySample(game->playerFallSample);
+        if (game->GetState() == STATE_GAME)
+            olc::SOUND::PlaySample(game->playerFallSample);
     }
 
     if (pos.x < size.x / 2) {
         vel.x *= -0.3;
         pos.x = size.x / 2;
-        olc::SOUND::PlaySample(game->playerFallSample);
+        if (game->GetState() == STATE_GAME)
+            olc::SOUND::PlaySample(game->playerFallSample);
     }
 
     auto groundLevel = game->GameScreenHeight() - size.y / 2 - 1;
     }
 
     bool newOnGround = pos.y >= groundLevel;
-    if (newOnGround && !onGround) {
+    if (newOnGround && !onGround && game->GetState() == STATE_GAME) {
         olc::SOUND::PlaySample(game->playerFallSample);
     }
     onGround = newOnGround;
 
 void Programmer::Draw()
 {
+    game->SetPixelMode(olc::Pixel::MASK);
     int xOff = walkLeft ? -1 : 0;
-    if (std::abs(vel.x) < 1) {
-        olc::GFX2D::DrawPartialSprite(&game->playerSprite, tile.x * size.x + xOff, size.y + tile.y * size.y, size.x - xOff, size.y, transform, true);
-    } else {
+    if (walkLeft || walkRight) {
         olc::GFX2D::DrawPartialSprite(&game->playerSprite, tile.x * size.x + xOff, 0 + tile.y * size.y, size.x - xOff, size.y, transform, true);
+    } else {
+        olc::GFX2D::DrawPartialSprite(&game->playerSprite, tile.x * size.x + xOff, size.y + tile.y * size.y, size.x - xOff, size.y, transform, true);
     }
+    game->SetPixelMode(olc::Pixel::NORMAL);
 #ifdef _DEBUG
     if (game->debug) {
         game->DrawRect(pos.x - size.x / 2, pos.y - size.y / 2, size.x, size.y, DEBUG_COLOR);
+        if (target.x != 0 || target.y != 0) {
+            game->DrawLine(pos.x, pos.y, target.x, target.y, DEBUG_COLOR);
+        }
     }
 #endif
 }