Player's 4-th stage

Change raw variables to vectors

Makefile

 
 OBJECTS=$(SOURCES:.cpp=.o)
 SPRITES=$(IMAGES:.png=.pgs)
-RESOURCES=$(SPRITES) $(wildcard res/*.wav) src/debuggers.cpp
+RESOURCES=$(SPRITES) $(wildcard res/*.wav) src/programmer.cpp
 
 PACK=debuggers.pgp
 

TODO.md

+ # TODO
+ - [ ] 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
+ - [ ] Reduce programmers spawn rate (maybe cubic function?)
+ - [ ] Add obstacles to prevent flying across the screen
+   - [ ] Edits by customer
+   - [ ] QA engineers

include/debuggers.h

     std::map<BonusType, uint32_t> bonusesCatched;
 
     uint32_t bugsCatched = 0;
+    uint32_t bugsCatchedByPlayer = 0;
     uint32_t bugsMissed = 0;
 
     uint8_t linesOfCode = 5;
     int bugCatchSample;
 
     const int gravity = 30;
+#ifdef _DEBUG
+    bool debug = true;
+#endif
 };
 }
 

include/entity.h

     Debuggers* game;
     olc::Sprite* sprite;
     olc::GFX2D::Transform2D transform;
-    float x, y;
-    float xv = 0, yv = 0;
-    int w, h;
+    olc::vf2d pos;
+    olc::vf2d vel;
+    olc::vi2d size;
 
-    uint8_t tileX = 0;
-    uint8_t tileY = 0;
-
-    uint8_t tileCols = 4;
-    uint8_t tileRows = 4;
+    olc::v2d_generic<uint8_t> tile{ 0, 0 };
+    olc::v2d_generic<uint8_t> tileDim{ 4, 4 };
 
     float rotation = 0;
     float rotationSpeed = 0;
+    bool alive = true;
 #ifdef _DEBUG
     olc::Pixel DEBUG_COLOR;
 #endif
     virtual void Update(float dt);
     virtual void Draw();
 
-    float GetX() { return x; }
-    float GetY() { return y; }
+    float GetX() { return pos.x; }
+    float GetY() { return pos.y; }
+
+    bool IsInScreen();
 
     bool Collides(Entity* entity);
-    float Dist(Entity* entity) { return std::hypot(x - entity->x, y - entity->y); }
+    float Dist(Entity* entity) { return (pos - entity->pos).mag(); }
 
     virtual bool IsActive();
+    virtual bool IsAlive();
     virtual void ResetPosition();
     virtual void Kill();
 };

include/programmer.h

     virtual void Update(float dt) override;
     virtual void Draw() override;
     bool IsOnGround() { return onGround; }
-    uint8_t GetSkin() { return tileX; }
-    void UpgradeLevel() { tileX = std::min(tileX + 1, tileCols - 1); }
+    uint8_t GetSkin() { return tile.x; }
+    void UpgradeLevel() { tile.x = std::min(tile.x + 1, tileDim.x - 1); }
 };
 }
 

src/bonus.cpp

 Bonus::Bonus(Debuggers* game)
     : Entity(game, &game->bonusesSprite)
 {
-    tileCols = 1;
-    tileRows = 3;
+    tileDim = { 1, 3 };
 #ifdef _DEBUG
     DEBUG_COLOR = olc::YELLOW;
 #endif
 
 BonusType Bonus::GetType()
 {
-    return static_cast<BonusType>(tileX * 4 + tileY);
+    return static_cast<BonusType>(tile.x * 4 + tile.y);
 }
 
 void Bonus::ResetPosition()

src/bug.cpp

 Bug::Bug(Debuggers* game)
     : Entity(game, &game->enemiesSprite)
 {
-    tileCols = 1;
+    tileDim.x = 1;
 #ifdef _DEBUG
     DEBUG_COLOR = olc::RED;
 #endif

src/debuggers.cpp

 #include "debuggers.h"
+#include <algorithm>
 #include <cmath>
 #include <ctime>
 #include <iostream>
     return str;
 }
 
+template <>
+float Debuggers::GetRandom<float>(float from, float to)
+{
+    if (from > to) {
+        std::swap(from, to);
+    }
+    std::uniform_real_distribution<float> dist(from, to);
+    return dist(generator);
+}
+
+template <>
+int Debuggers::GetRandom<int>(int from, int to)
+{
+    if (from > to) {
+        std::swap(from, to);
+    }
+    std::uniform_int_distribution<int> dist(from, to - 1);
+    return dist(generator);
+}
+
 bool Debuggers::OnUserCreate()
 {
     SetPixelMode(olc::Pixel::MASK);
         return false;
     }
 
-    fileName = "src/debuggers.cpp";
+    fileName = "src/programmer.cpp";
     auto streamBuffer = pack.GetStreamBuffer(fileName);
     if (streamBuffer.data == nullptr) {
         std::cerr << "[Load source] File " << fileName << " is not found" << std::endl;
     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()) {
             for (auto& programmer : programmers) {
                 if (programmer->Collides(bug)) {
                     bugsCatched++;
+                    if (programmer == player) {
+                        bugsCatchedByPlayer++;
+                    }
                     bug->Kill();
                     olc::SOUND::PlaySample(bugCatchSample);
                     SpawnBug();
                 }
             }
-        } else {
+        } else if (bug->IsAlive()) {
             bugsMissed++;
             sourceCode.erase(sourceCode.begin());
 
         }
     }
 
-    Programmer* player = programmers.at(0);
-
     for (auto& bonus : bonuses) {
         if (bonus->IsActive()) {
             bonus->Update(fElapsedTime);
             bonus->Draw();
             if (player->Collides(bonus)) {
-                bonusesCatched[bonus->GetType()]++;
+                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();
         }
     }
 
         SpawnBug();
     }
 
-    if (bugsCatched >= 15 * bugsSize * programmers.size() && player->GetSkin() < bugsSize) {
+    auto programmersSize = programmers.size();
+    if (bugsCatchedByPlayer >= 15 * programmersSize * programmersSize && player->GetSkin() < programmersSize) {
         player->UpgradeLevel();
         SpawnBug();
-        SpawnBug();
         SpawnProgrammer();
     }
 
-#ifdef _DEBUG
-    DrawString(1, 37, "Bugs: " + std::to_string(bugs.size()));
-    DrawString(1, 46, "Progs: " + std::to_string(programmers.size()));
-    DrawString(1, 55, "Bonuses: " + std::to_string(bonuses.size()));
-    DrawString(1, 64, "DBG: " + std::to_string(bonusesCatched[BONUS_DEBUGGER]));
-    DrawString(1, 73, "UTS: " + std::to_string(bonusesCatched[BONUS_UNIT_TEST]));
-    DrawString(1, 82, "DOC: " + std::to_string(bonusesCatched[BONUS_DOCUMENTATION]));
-    
-    if (GetKey(olc::B).bPressed) {
+    if (bugsCatched > 10 * bugsSize) {
         SpawnBug();
     }
-    if (GetKey(olc::N).bPressed) {
+
+    if (GetRandom<float>() < 0.01 * fElapsedTime) {
         SpawnBonus();
     }
-    if (GetKey(olc::P).bPressed) {
-        SpawnProgrammer();
+
+#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();
+        }
+        if (GetKey(olc::N).bPressed) {
+            SpawnBonus();
+        }
+        if (GetKey(olc::P).bPressed) {
+            SpawnProgrammer();
+        }
+    }
+    if (GetKey(olc::K0).bReleased) {
+        debug = !debug;
     }
 #endif
     DrawString(1, 1, "A,S,D - move; SPACE - jump", olc::CYAN);
 Bug* Debuggers::CreateBug()
 {
     for (auto bug : bugs) {
-        if (!bug->IsActive())
+        if (!bug->IsActive() || !bug->IsAlive())
             return bug;
     }
     auto bug = new Bug(this);
     olc::SOUND::DestroyAudio();
     return true;
 }
-
-template <>
-float Debuggers::GetRandom<float>(float from, float to)
-{
-    if (from > to) {
-        std::swap(from, to);
-    }
-    std::uniform_real_distribution<double> dist(from, to);
-    return dist(generator);
-}
-
-template <>
-int Debuggers::GetRandom<int>(int from, int to)
-{
-    if (from > to) {
-        std::swap(from, to);
-    }
-    std::uniform_int_distribution<int> dist(from, to - 1);
-    return dist(generator);
-}
 }

src/entity.cpp

 #include "debuggers.h"
 
 namespace pabloader {
-Entity::Entity(Debuggers* game, olc::Sprite* s): sprite(s), w(s->width / 4), h(s->height / 4)
+Entity::Entity(Debuggers* game, olc::Sprite* s)
+    : sprite(s)
+    , pos(0, 0)
+    , vel(0, 0)
+    , size(s->width / 4, s->height / 4)
 {
     Entity::game = game;
 }
 
 void Entity::Update(float dt)
 {
-    y += yv * dt;
-    yv += game->gravity * dt;
+    pos += vel * dt;
+    pos.y += game->gravity * dt;
 
     rotation += rotationSpeed * dt;
 
     transform.Reset();
     transform.Rotate(rotation);
-    transform.Translate(x, y);
+    transform.Translate(pos.x, pos.y);
 }
 
 bool Entity::Collides(Entity* entity)
 {
-    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);
+    bool collidesX = (pos.x - size.x / 2 < entity->pos.x + entity->size.x / 2) && (entity->pos.x - entity->size.x / 2 < pos.x + size.x / 2);
+    bool collidesY = (pos.y - size.y / 2 < entity->pos.y + entity->size.y / 2) && (entity->pos.y - entity->size.y / 2 < pos.y + size.y / 2);
     return collidesX && collidesY;
 }
 
 void Entity::Draw()
 {
 #ifdef _DEBUG
-    game->DrawRect(x - w / 2, y - h / 2, w, h, DEBUG_COLOR);
+    if (game->debug) {
+        game->DrawRect(pos.x - size.x / 2, pos.y - size.y / 2, size.x, size.y, DEBUG_COLOR);
+    }
 #endif
-    olc::GFX2D::DrawPartialSprite(sprite, tileX * w, tileY * h, w, h, transform, true);
+    olc::GFX2D::DrawPartialSprite(sprite, tile.x * size.x, tile.y * size.y, size.x, size.y, transform, true);
 }
 
 bool Entity::IsActive()
 {
-    return y - h / 2 < game->GameScreenHeight();
+    return pos.y - size.y / 2 < game->GameScreenHeight();
+}
+bool Entity::IsInScreen()
+{
+    return pos.x > -size.x / 2 && pos.y > -size.y
+        && pos.x < game->ScreenWidth() + size.x / 2
+        && pos.x < game->ScreenHeight() + size.y / 2;
+}
+
+bool Entity::IsAlive()
+{
+    return alive;
 }
 
 void Entity::ResetPosition()
 {
-    y = game->GetRandom(-20, -game->ScreenHeight());
-    x = game->GetRandom(w, game->ScreenWidth() - w);
-    yv = 0;
-    tileX = game->GetRandom<int>(0, tileCols);
-    tileY = game->GetRandom<int>(0, tileRows);
+    pos.x = game->GetRandom(size.x, game->ScreenWidth() - size.x);
+    pos.y = game->GetRandom(-20, -game->ScreenHeight());
+    vel.x = 0;
+    vel.y = 0;
+    tile.x = game->GetRandom<int>(0, tileDim.x);
+    tile.y = game->GetRandom<int>(0, tileDim.y);
     rotationSpeed = game->GetRandom(-3.14f, 3.14f);
+    alive = true;
 }
 
 void Entity::Kill()
 {
-    y = game->ScreenHeight() + 100;
+    pos.y = game->ScreenHeight() + 100;
+    alive = false;
 }
 }

src/player.cpp

     walkRight = game->GetKey(olc::D).bHeld;
     moveDown = game->GetKey(olc::S).bHeld;
 #ifdef _DEBUG
-    // 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->debug) {
+        // 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) {
-        tileX = (tileX + 1) % tileCols;
+        if (game->GetKey(olc::J).bPressed) {
+            tile.x = (tile.x + 1) % tileDim.x;
+        }
     }
 #endif
 }

src/programmer.cpp

 Programmer::Programmer(Debuggers* game)
     : Entity(game, &game->playerSprite)
 {
-    x = (game->ScreenWidth() - w) / 2;
-    y = h / 2;
-    tileCols = 3;
+    pos = { (float)(game->ScreenWidth() - size.x) / 2, (float)size.y / 2 };
 
 #ifdef _DEBUG
     DEBUG_COLOR = olc::GREEN;
     float dist = 1e100;
     for (auto bug : game->bugs) {
         float d = bug->Dist(this);
-        if (d < dist && bug->GetY() > 0) {
+        if (d < dist && bug->IsInScreen() && bug->IsAlive()) {
             dist = d;
             closest = bug;
         }
     }
 
     if (closest != nullptr) {
-        doJump = closest->GetY() < y;
-        moveDown = closest->GetY() > y;
-        walkLeft = closest->GetX() < x;
-        walkRight = closest->GetX() > x;
+        doJump = closest->GetY() < pos.y;
+        moveDown = closest->GetY() > pos.y;
+        walkLeft = closest->GetX() < pos.x;
+        walkRight = closest->GetX() > pos.x;
     } else {
         doJump = false;
         walkLeft = false;
 
 void Programmer::Update(float dt)
 {
-    x += xv * dt;
-    y += yv * dt;
+    pos += vel * dt;
 
-    xv *= 1 - 0.2 * dt;
+    vel.x *= 1 - 0.2 * dt;
 
     if (!onGround) {
-        yv += (70 + tileX * 30) * dt;
-        yv *= 1 - 0.05 * dt;
+        vel.y += (70 + tile.x * 30) * dt;
+        vel.y *= 1 - 0.05 * dt;
     } else {
-        xv *= 1 - dt;
+        vel.x *= 1 - 3 * dt;
     }
 
     transform.Reset();
     bool userInput = false;
 
     if (doJump && onGround) {
-        yv = -100 - 50 * tileX;
+        vel.y = -100 - tile.x * 30;
         userInput = true;
     }
 
     if (walkLeft) {
-        xv -= (150 + tileX * 50) * dt;
+        vel.x -= (150 + tile.x * 30) * dt;
         userInput = true;
     }
 
     if (walkRight) {
-        xv += (150 + tileX * 50) * dt;
+        vel.x += (150 + tile.x * 30) * dt;
         userInput = true;
     }
 
     if (moveDown) {
         if (!onGround) {
-            yv += (150 + tileX * 50) * dt;
+            vel.y += (150 + tile.x * 30) * dt;
         }
         userInput = true;
     }
 
-    if (x > game->ScreenWidth() - w / 2) {
-        xv *= -0.3;
-        x = game->ScreenWidth() - w / 2;
+    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 (x < w / 2) {
-        xv *= -0.3;
-        x = w / 2;
+    if (pos.x < size.x / 2) {
+        vel.x *= -0.3;
+        pos.x = size.x / 2;
         olc::SOUND::PlaySample(game->playerFallSample);
     }
 
-    if (y > game->GameScreenHeight() - h / 2) {
-        yv *= -0.3;
+    auto groundLevel = game->GameScreenHeight() - size.y / 2 - 1;
 
-        if (std::abs(yv) < 2) {
-            yv = 0;
+    if (pos.y > groundLevel) {
+        vel.y *= -0.3;
+
+        if (std::abs(vel.y) < 2) {
+            vel.y = 0;
         }
-        y = game->GameScreenHeight() - h / 2;
+        pos.y = groundLevel;
     }
 
-    bool newOnGround = y >= game->GameScreenHeight() - h / 2;
+    bool newOnGround = pos.y >= groundLevel;
     if (newOnGround && !onGround) {
         olc::SOUND::PlaySample(game->playerFallSample);
     }
     onGround = newOnGround;
 
     if (onGround) {
-        tileY = 2;
+        tile.y = 2;
         tileCounter = static_cast<uint32_t>(0.1 / dt);
     } else if (tileCounter <= 0) {
-        tileY = 0;
+        tile.y = 0;
     } else {
         tileCounter--;
     }
 
-    if (!userInput && std::abs(xv) < 2) {
-        xv = 0;
+    if (!userInput && std::abs(vel.x) < 2) {
+        vel.x = 0;
     }
-    if (xv < 0) {
+    if (vel.x < 0) {
         transform.Scale(-1, 1);
     }
-    transform.Translate(x, y);
+    transform.Translate(pos.x, pos.y);
 }
 
 void Programmer::Draw()
 {
-    int xOff = xv < 0 ? -1 : 0;
-    if (std::abs(xv) < 1) {
-        olc::GFX2D::DrawPartialSprite(&game->playerSprite, tileX * w + xOff, h + tileY * h, w - xOff, h, transform, true);
+    int xOff = vel.x < 0 ? -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 {
-        olc::GFX2D::DrawPartialSprite(&game->playerSprite, tileX * w + xOff, 0 + tileY * h, w - xOff, h, transform, true);
+        olc::GFX2D::DrawPartialSprite(&game->playerSprite, tile.x * size.x + xOff, 0 + tile.y * size.y, size.x - xOff, size.y, transform, true);
     }
 #ifdef _DEBUG
-    game->DrawRect(x - w / 2, y - h / 2, w, h, DEBUG_COLOR);
+    if (game->debug) {
+        game->DrawRect(pos.x - size.x / 2, pos.y - size.y / 2, size.x, size.y, DEBUG_COLOR);
+    }
 #endif
 }
 }