Score counting, display source code, graphics

.gitignore

 awoorwa
-awoorwae
+debuggers
 *.exe
 *.o
 *.pgp

.vscode/launch.json

             ]
         },
         {
-            "name": "(gdb-win) Launch Awoorwae",
+            "name": "(gdb-win) Launch Debuggers",
             "type": "cppdbg",
             "request": "launch",
-            "program": "${workspaceFolder}\\awoorwae.exe",
+            "program": "${workspaceFolder}\\debuggers.exe",
             "args": [],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",
             "name": "(gdb) Launch",
             "type": "cppdbg",
             "request": "launch",
-            "program": "${workspaceFolder}/awoorwae",
+            "program": "${workspaceFolder}/debuggers",
             "args": [],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",

Makefile

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

include/awoorwae.h

-#ifndef AWOORWAE_H
-#define AWOORWAE_H
-
-#include "olcPixelGameEngine.h"
-#include "olcPGEX_Sound.h"
-#include "player.h"
-#include "bug.h"
-#include <vector>
-
-namespace pabloader {
-class Awoorwae : public olc::PixelGameEngine {
-private:
-    Player* player;
-    std::vector<Bug*> bugs;
-
-public:
-    Awoorwae()
-    {
-        sAppName = "Awoorwa";
-    }
-
-    ~Awoorwae()
-    {
-        delete player;
-    }
-
-public:
-    bool OnUserCreate() override;
-    bool OnUserUpdate(float fElapsedTime) override;
-    bool OnUserDestroy() override;
-
-private:
-    Bug* SpawnBug();
-
-public:
-    olc::ResourcePack pack;
-    olc::Sprite playerSprite;
-    olc::Sprite enemiesSprite;
-    int playerFallSample;
-};
-}
-
-#endif

include/bug.h

 namespace pabloader {
 class Bug : public Entity {
 public:
-    Bug(Awoorwae* game);
+    Bug(Debuggers* game);
     void Update(float dt) override;
     void Draw() override;
     bool IsActive();
     void ResetPosition();
+    void Kill();
 
 private:
     int kind = 0;

include/debuggers.h

+#ifndef DEBUGGERS_H
+#define DEBUGGERS_H
+
+#include "bug.h"
+#include "olcPGEX_Sound.h"
+#include "olcPixelGameEngine.h"
+#include "player.h"
+#include <vector>
+#include <string>
+
+namespace pabloader {
+class Debuggers : public olc::PixelGameEngine {
+private:
+    Player* player;
+    std::vector<Bug*> bugs;
+    uint32_t bugsCatched = 0;
+    uint32_t bugsMissed = 0;
+
+    uint8_t linesOfCode = 5;
+    uint16_t totalLines;
+    std::vector<std::string> sourceCode;
+
+public:
+    Debuggers()
+    {
+        sAppName = "Debuggers";
+    }
+
+public:
+    bool OnUserCreate() override;
+    bool OnUserUpdate(float fElapsedTime) override;
+    bool OnUserDestroy() override;
+    int GameScreenHeight() { return ScreenHeight() - linesOfCode * 10; };
+
+private:
+    void SpawnBug();
+    Bug* CreateBug();
+    bool GameOver();
+
+public:
+    olc::ResourcePack pack;
+    olc::Sprite playerSprite;
+    olc::Sprite enemiesSprite;
+    olc::Sprite backgroundSprite;
+    int playerFallSample;
+    int bugFallSample;
+    int bugCatchSample;
+};
+}
+
+#endif

include/entity.h

 #include "olcPixelGameEngine.h"
 
 namespace pabloader {    
-class Awoorwae;
+class Debuggers;
 
 class Entity {
 protected:
-    Awoorwae* game;
+    Debuggers* game;
     olc::GFX2D::Transform2D transform;
     float x, y;
     float xv, yv;
     int w, h;
 
 public:
-    Entity(Awoorwae* game_);
+    Entity(Debuggers* game_);
     virtual ~Entity(){};
     
     virtual void Update(float dt) = 0;

include/player.h

 namespace pabloader {
 
 class Player : public Entity {
+private:
+    uint8_t tile = 0;
+    uint8_t skin = 0;
+    uint32_t tileCounter = 0;
+    bool onGround = false;
+
 public:
-    Player(Awoorwae* game);
+    Player(Debuggers* game);
     void Update(float dt) override;
     void Draw() override;
-
-private:
-    int tile = 0;
-    int skin = 0;
-    int tileCounter = 0;
-    bool onGround = false;
+    bool IsOnGround() { return onGround; }
+    uint8_t GetSkin() { return skin; }
+    void UpgradeLevel() { skin = std::min(skin + 1, 3); }
 };
 }
 

pge/include/olcPixelGameEngine.h

 		// Flat fills a triangle between points (x1,y1), (x2,y2) and (x3,y3)
 		void FillTriangle(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t x3, int32_t y3, Pixel p = olc::WHITE);
 		// Draws an entire sprite at location (x,y)
-		void DrawSprite(int32_t x, int32_t y, Sprite *sprite, uint32_t scale = 1);
+		void DrawSprite(int32_t x, int32_t y, Sprite *sprite, uint32_t scale = 1, bool centered = false);
 		// Draws an area of a sprite at location (x,y), where the
 		// selected area is (ox,oy) to (ox+w,oy+h)
-		void DrawPartialSprite(int32_t x, int32_t y, Sprite *sprite, int32_t ox, int32_t oy, int32_t w, int32_t h, uint32_t scale = 1);
+		void DrawPartialSprite(int32_t x, int32_t y, Sprite *sprite, int32_t ox, int32_t oy, int32_t w, int32_t h, uint32_t scale = 1, bool centered = false);
 		// Draws a single line of text
 		void DrawString(int32_t x, int32_t y, std::string sText, Pixel col = olc::WHITE, uint32_t scale = 1);
 		// Clears entire draw target to Pixel

pge/src/olcPixelGameEngine.cpp

 		}
 	}
 
-	void PixelGameEngine::DrawSprite(int32_t x, int32_t y, Sprite *sprite, uint32_t scale)
+	void PixelGameEngine::DrawSprite(int32_t x, int32_t y, Sprite *sprite, uint32_t scale, bool centered)
 	{
 		if (sprite == nullptr)
 			return;
 
+		int32_t xOff = 0;
+		int32_t yOff = 0;
+		if (centered) {
+			xOff += sprite->width /2;
+			yOff += sprite->height /2;
+		}
+
 		if (scale > 1)
 		{
 			for (int32_t i = 0; i < sprite->width; i++)
 				for (int32_t j = 0; j < sprite->height; j++)
 					for (uint32_t is = 0; is < scale; is++)
 						for (uint32_t js = 0; js < scale; js++)
-							Draw(x + (i*scale) + is, y + (j*scale) + js, sprite->GetPixel(i, j));
+							Draw(x + (i*scale) + is - xOff, y + (j*scale) + js - yOff, sprite->GetPixel(i, j));
 		}
 		else
 		{
 			for (int32_t i = 0; i < sprite->width; i++)
 				for (int32_t j = 0; j < sprite->height; j++)
-					Draw(x + i, y + j, sprite->GetPixel(i, j));
+					Draw(x + i - xOff, y + j - yOff, sprite->GetPixel(i, j));
 		}
 	}
 
-	void PixelGameEngine::DrawPartialSprite(int32_t x, int32_t y, Sprite *sprite, int32_t ox, int32_t oy, int32_t w, int32_t h, uint32_t scale)
+	void PixelGameEngine::DrawPartialSprite(int32_t x, int32_t y, Sprite *sprite, int32_t ox, int32_t oy, int32_t w, int32_t h, uint32_t scale, bool centered)
 	{
 		if (sprite == nullptr)
 			return;
 
+		int32_t xOff = 0;
+		int32_t yOff = 0;
+		if (centered) {
+			xOff += w /2;
+			yOff += h /2;
+		}
+
 		if (scale > 1)
 		{
 			for (int32_t i = 0; i < w; i++)
 				for (int32_t j = 0; j < h; j++)
 					for (uint32_t is = 0; is < scale; is++)
 						for (uint32_t js = 0; js < scale; js++)
-							Draw(x + (i*scale) + is, y + (j*scale) + js, sprite->GetPixel(i + ox, j + oy));
+							Draw(x + (i*scale) + is - xOff, y + (j*scale) + js - yOff, sprite->GetPixel(i + ox, j + oy));
 		}
 		else
 		{
 			for (int32_t i = 0; i < w; i++)
 				for (int32_t j = 0; j < h; j++)
-					Draw(x + i, y + j, sprite->GetPixel(i + ox, j + oy));
+					Draw(x + i - xOff, y + j - yOff, sprite->GetPixel(i + ox, j + oy));
 		}
 	}
 

src/awoorwae.cpp

-#include "awoorwae.h"
-#include <cmath>
-#include <iostream>
-#include <string>
-
-namespace pabloader {
-
-bool Awoorwae::OnUserCreate()
-{
-    SetPixelMode(olc::Pixel::MASK);
-    
-    if (!olc::SOUND::InitialiseAudio()) {
-        std::cerr << "Cannot init audio" << std::endl;
-        return false;
-    }
-
-    if (!pack.LoadPack("awoorwae.pgp")) {
-        std::cerr << "Cannot load resource pack res/awoorwae.pgp" << std::endl;
-        return false;
-    }
-
-    // Load Player
-
-    std::string fileName = "res/player.pgs";
-    if (!playerSprite.LoadFromPGESprFile(fileName, &pack)) {
-        std::cerr << "[Load player] File " << fileName << " is not found" << std::endl;
-        return false;
-    }
-
-    fileName = "res/fall.wav";
-    playerFallSample = olc::SOUND::LoadAudioSample(fileName, &pack);
-    if (playerFallSample < 0) {
-        std::cerr << "[Load fall] File " << fileName << " is not found" << std::endl;
-        return false;
-    }
-
-    // Load enemies
-
-    fileName = "res/enemies.pgs";
-    if (!enemiesSprite.LoadFromPGESprFile(fileName, &pack)) {
-        std::cerr << "[Load enemies] File " << fileName << " is not found" << std::endl;
-        return false;
-    }
-
-    // Free Memory
-    pack.ClearPack();
-
-    // Creating entities
-    
-    player = new Player(this);
-    return true;
-}
-
-bool Awoorwae::OnUserUpdate(float fElapsedTime)
-{
-    Clear(olc::VERY_DARK_CYAN);
-
-    player->Update(fElapsedTime);
-    player->Draw();
-
-    for (auto bug : bugs) {
-        if (bug->IsActive()) {
-            bug->Update(fElapsedTime);
-            bug->Draw();
-            if (player->Collides(bug)) {
-                // TODO smth
-            }
-        }
-    }
-
-#ifdef _DEBUG
-    DrawString(1, 28, "Bugs: " + std::to_string(bugs.size()));
-#endif
-    if (GetKey(olc::B).bPressed) {
-        auto bug = SpawnBug();
-        bug->ResetPosition();
-    }
-
-    return true;
-}
-
-bool Awoorwae::OnUserDestroy()
-{
-    olc::SOUND::DestroyAudio();
-    return true;
-}
-
-Bug* Awoorwae::SpawnBug()
-{
-    for (auto bug : bugs) {
-        if (!bug->IsActive())
-            return bug;
-    }
-    auto bug = new Bug(this);
-    bugs.push_back(bug);
-    return bug;
-}
-}

src/bug.cpp

 #include "bug.h"
-#include "awoorwae.h"
+#include "debuggers.h"
 #include <iostream>
 #include <random>
 
 namespace pabloader {
-Bug::Bug(Awoorwae* game_)
+Bug::Bug(Debuggers* game_)
     : Entity(game_)
 {
     w = game->enemiesSprite.width / 4;
 void Bug::Update(float dt)
 {
     y += yv * dt;
-    yv += 50 * dt;
+    yv += 30 * dt;
 }
 
 void Bug::Draw()
 {
 #ifdef _DEBUG
-    game->DrawRect(x, y, w, h, olc::RED);
+    game->DrawRect(x - w / 2, y - h / 2, w, h, olc::RED);
 #endif
-    game->DrawPartialSprite(x, y, &game->enemiesSprite, 0, kind * h, w, h);
+    game->DrawPartialSprite(x, y, &game->enemiesSprite, 0, kind * h, w, h, 1, true);
 }
 
 bool Bug::IsActive()
 {
-    return y < game->ScreenHeight();
+    return y - h / 2 < game->GameScreenHeight();
 }
 
 void Bug::ResetPosition()
 {
-    y = -20;
+    y = -20 - std::rand() % 100;
     x = w + std::rand() % (game->ScreenWidth() - w * 2);
     yv = 0;
     kind = std::rand() % 4;
 }
+
+void Bug::Kill()
+{
+    y = game->GameScreenHeight() + 100;
+}
 }

src/debuggers.cpp

+#include "debuggers.h"
+#include <cmath>
+#include <iostream>
+
+namespace pabloader {
+std::string& rtrim(std::string& str, const std::string& chars = "\t\n\v\f\r ")
+{
+    str.erase(str.find_last_not_of(chars) + 1);
+    return str;
+}
+
+bool Debuggers::OnUserCreate()
+{
+    SetPixelMode(olc::Pixel::MASK);
+
+    if (!olc::SOUND::InitialiseAudio()) {
+        std::cerr << "Cannot init audio" << std::endl;
+        return false;
+    }
+
+    if (!pack.LoadPack("debuggers.pgp")) {
+        std::cerr << "Cannot load resource pack res/debuggers.pgp" << std::endl;
+        return false;
+    }
+
+    // Load Player
+
+    std::string fileName = "res/player.pgs";
+    if (!playerSprite.LoadFromPGESprFile(fileName, &pack)) {
+        std::cerr << "[Load player] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
+    fileName = "res/fall.wav";
+    playerFallSample = olc::SOUND::LoadAudioSample(fileName, &pack);
+    if (playerFallSample < 0) {
+        std::cerr << "[Load fall] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
+    // Load enemies
+
+    fileName = "res/enemies.pgs";
+    if (!enemiesSprite.LoadFromPGESprFile(fileName, &pack)) {
+        std::cerr << "[Load enemies] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
+    fileName = "res/bug_fall.wav";
+    bugFallSample = olc::SOUND::LoadAudioSample(fileName, &pack);
+    if (bugFallSample < 0) {
+        std::cerr << "[Load bug fall] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
+    fileName = "res/bug_catch.wav";
+    bugCatchSample = olc::SOUND::LoadAudioSample(fileName, &pack);
+    if (bugCatchSample < 0) {
+        std::cerr << "[Load bug catch] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
+    // Load background
+
+    fileName = "res/bg.pgs";
+    if (!backgroundSprite.LoadFromPGESprFile(fileName, &pack)) {
+        std::cerr << "[Load background] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
+    fileName = "src/debuggers.cpp";
+    auto streamBuffer = pack.GetStreamBuffer(fileName);
+    if (streamBuffer.data == nullptr) {
+        std::cerr << "[Load source] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+    std::istream is(&streamBuffer);
+    std::string line;
+    while (std::getline(is, line)) {
+        if (!rtrim(line).empty())
+            sourceCode.push_back(line);
+    }
+
+    totalLines = sourceCode.size();
+
+    // Free Memory
+    pack.ClearPack();
+
+    // Creating entities
+
+    player = new Player(this);
+    return true;
+}
+
+bool Debuggers::OnUserUpdate(float fElapsedTime)
+{
+    if (!IsFocused())
+        return true;
+
+    if (sourceCode.size() == 0) {
+        return GameOver();
+    }
+
+    DrawSprite(0, 0, &backgroundSprite);
+
+    DrawString(1, 1, "A,S,D - move; SPACE - jump", olc::CYAN);
+    DrawString(1, 10, "Don't let the bugs destroy your code!", olc::YELLOW);
+
+    player->Update(fElapsedTime);
+    player->Draw();
+
+    uint32_t bugsSize = bugs.size();
+
+    if (bugsSize == 0 && player->IsOnGround()) {
+        SpawnBug();
+    }
+
+    if (bugsCatched >= bugsSize * 25 && player->GetSkin() < bugsSize) {
+        player->UpgradeLevel();
+        SpawnBug();
+    }
+
+    for (auto bug : bugs) {
+        if (bug->IsActive()) {
+            bug->Update(fElapsedTime);
+            bug->Draw();
+            if (player->Collides(bug)) {
+                bugsCatched++;
+                bug->Kill();
+                olc::SOUND::PlaySample(bugCatchSample);
+                SpawnBug();
+            }
+        } else {
+            bugsMissed++;
+            sourceCode.erase(sourceCode.begin());
+
+            SpawnBug();
+            olc::SOUND::PlaySample(bugFallSample);
+        }
+    }
+
+    linesOfCode = (sourceCode.size() * 4 / totalLines)  +1;
+
+#ifdef _DEBUG
+    DrawString(1, 37, "Bugs: " + std::to_string(bugs.size()));
+    if (GetKey(olc::B).bPressed) {
+        SpawnBug();
+    }
+#endif
+    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;
+    }
+
+    return true;
+}
+
+bool Debuggers::GameOver()
+{
+    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);
+
+    return true;
+}
+
+bool Debuggers::OnUserDestroy()
+{
+    olc::SOUND::DestroyAudio();
+    return true;
+}
+
+void Debuggers::SpawnBug()
+{
+    auto bug = CreateBug();
+    bug->ResetPosition();
+}
+
+Bug* Debuggers::CreateBug()
+{
+    for (auto bug : bugs) {
+        if (!bug->IsActive())
+            return bug;
+    }
+    auto bug = new Bug(this);
+    bugs.push_back(bug);
+    return bug;
+}
+}

src/entity.cpp

 #include "entity.h"
 
 namespace pabloader {
-Entity::Entity(Awoorwae* game)
+Entity::Entity(Debuggers* game)
 {
     xv = 0;
     yv = 0;
 
 bool Entity::Collides(Entity* entity)
 {
-    bool collidesX = (x < entity->x + entity->w) && (entity->x < x + w);
-    bool collidesY = (y < entity->y + entity->h) && (entity->y < y + h);
+    bool collidesX = (x - w / 2 < entity->x + entity->w / 2) && (entity->x - entity->w / 2 < x + w / 2);
+    bool collidesY = (y - h / 2 < entity->y + entity->h / 2) && (entity->y - entity->h / 2 < y + h / 2);
     return collidesX && collidesY;
 }
 }

src/main.cpp

-#include "awoorwae.h"
+#include "debuggers.h"
 
 int main()
 {
-    pabloader::Awoorwae game;
+    pabloader::Debuggers game;
     if (game.ConstructAuto(320, 240))
         game.Start();
 

src/player.cpp

 #include "player.h"
-#include "awoorwae.h"
+#include "debuggers.h"
 #include "olcPGEX_Sound.h"
 #include <iostream>
 
 namespace pabloader {
-Player::Player(Awoorwae* game_)
+Player::Player(Debuggers* game_)
     : Entity(game_)
 {
     w = game->playerSprite.width / 4;
     h = game->playerSprite.height / 4;
     x = (game->ScreenWidth() - w) / 2;
-    y = game->ScreenHeight() / 2;
+    y = game->GameScreenHeight() / 2;
 }
 
 void Player::Update(float dt)
     xv *= 1 - 0.2 * dt;
 
     if (!onGround) {
-        yv += 50 * dt;
+        yv += (70 + skin * 20) * dt;
         yv *= 1 - 0.05 * dt;
     } else {
         xv *= 1 - 0.5 * dt;
 
     transform.Reset();
 
-    game->DrawString(1, 1, "A,D - move; SPACE - jump", olc::CYAN);
-
 #ifdef _DEBUG
-    game->DrawString(1, 10, std::to_string(x) + " " + std::to_string(y));
-    game->DrawString(1, 19, std::to_string(xv) + " " + std::to_string(yv));
+    // game->DrawString(1, 19, std::to_string(x) + " " + std::to_string(y));
+    // game->DrawString(1, 28, std::to_string(xv) + " " + std::to_string(yv));
+
+    if (game->GetKey(olc::J).bPressed) {
+        skin = (skin + 1) % 4;
+    }
 #endif
     bool userInput = false;
 
     }
 
     if (game->GetKey(olc::A).bHeld) {
-        xv -= 100 * dt;
+        xv -= (100 + skin * 50) * dt;
         userInput = true;
     }
 
     if (game->GetKey(olc::D).bHeld) {
-        xv += 100 * dt;
+        xv += (100 + skin * 50) * dt;
         userInput = true;
     }
 
-    if (game->GetKey(olc::J).bPressed) {
-        skin = 1 - skin;
+    if (game->GetKey(olc::S).bHeld) {
+        if (!onGround) {
+            yv += (100 + skin * 50) * dt;
+        }
+        userInput = true;
     }
 
     if (x > game->ScreenWidth() - w / 2) {
         olc::SOUND::PlaySample(game->playerFallSample);
     }
 
-    if (y > game->ScreenHeight() - h / 2) {
+    if (y > game->GameScreenHeight() - h / 2) {
         yv *= -0.3;
 
         if (std::abs(yv) < 2) {
             yv = 0;
         }
-        y = game->ScreenHeight() - h / 2;
+        y = game->GameScreenHeight() - h / 2;
     }
 
-    bool newOnGround = y >= game->ScreenHeight() - h / 2;
+    bool newOnGround = y >= game->GameScreenHeight() - h / 2;
     if (newOnGround && !onGround) {
         olc::SOUND::PlaySample(game->playerFallSample);
     }
 
     if (onGround) {
         tile = 2;
-        tileCounter = 30;
+        tileCounter = static_cast<uint32_t>(0.1 / dt);
     } else if (tileCounter <= 0) {
         tile = 0;
     } else {
 #ifdef _DEBUG
     float x, y;
     transform.Forward(0, 0, x, y);
-    game->Draw((int)x, (int)y, olc::RED);
+    game->DrawRect((int)x - w / 2, (int)y - h / 2, w, h, olc::RED);
 #endif
 }
 }