Modern random numbers generator, deduplicate some code, Bonus class

.vscode/c_cpp_properties.json

             "includePath": [
                 "${workspaceFolder}/**"
             ],
-            "defines": [],
+            "defines": [
+                "_DEBUG"
+            ],
             "compilerPath": "/usr/bin/gcc",
             "cStandard": "c11",
             "cppStandard": "c++17",

include/bonus.h

+#ifndef BONUS_H
+#define BONUS_H
+
+#include "entity.h"
+
+namespace pabloader {
+class Bonus : public Entity {
+public:
+    Bonus(Debuggers* game);
+};
+}
+
+#endif

include/bug.h

 class Bug : public Entity {
 public:
     Bug(Debuggers* game);
-    void Update(float dt) override;
-    void Draw() override;
-    bool IsActive();
-    void ResetPosition();
-    void Kill();
-
-private:
-    int kind = 0;
-    float rotation = 0;
-    int8_t rotationSpeed;
 };
 }
 

include/debuggers.h

 #ifndef DEBUGGERS_H
 #define DEBUGGERS_H
 
-#include "bug.h"
 #include "olcPGEX_Sound.h"
 #include "olcPixelGameEngine.h"
-#include "programmer.h"
+
+#include "bonus.h"
+#include "bug.h"
 #include "player.h"
-#include <vector>
+#include "programmer.h"
+
 #include <string>
+#include <vector>
+#include <random>
+#include <chrono>
 
 namespace pabloader {
 class Debuggers : public olc::PixelGameEngine {
 private:
     std::vector<Programmer*> programmers;
+    std::vector<Bonus*> bonuses;
+
     uint32_t bugsCatched = 0;
     uint32_t bugsMissed = 0;
 
     uint8_t linesOfCode = 5;
     uint16_t totalLines;
     std::vector<std::string> sourceCode;
+    std::random_device rd;
+    std::mt19937 generator;
 
 public:
-    Debuggers()
+    Debuggers(): generator(rd())
     {
         sAppName = "Debuggers";
     }
     bool OnUserDestroy() override;
     int GameScreenHeight() { return ScreenHeight() - linesOfCode * 10; };
 
+    template <typename T>
+    T GetRandom(T from = 0, T to = 1);
+
 private:
     void SpawnProgrammer();
     void SpawnBug();
+    void SpawnBonus();
     Bug* CreateBug();
+    Bonus* CreateBonus();
     bool GameOver();
 
 public:
     std::vector<Bug*> bugs;
 
     olc::ResourcePack pack;
+
     olc::Sprite playerSprite;
     olc::Sprite enemiesSprite;
+    olc::Sprite bonusesSprite;
     olc::Sprite backgroundSprite;
+
     int playerFallSample;
     int bugFallSample;
     int bugCatchSample;
+
+    const int gravity = 30;
 };
 }
 

include/entity.h

 class Entity {
 protected:
     Debuggers* game;
+    olc::Sprite* sprite;
     olc::GFX2D::Transform2D transform;
     float x, y;
-    float xv, yv;
+    float xv = 0, yv = 0;
     int w, h;
 
+    uint8_t tileX = 0;
+    uint8_t tileY = 0;
+
+    uint8_t tileCols = 4;
+    uint8_t tileRows = 4;
+
+    float rotation = 0;
+    float rotationSpeed = 0;
+#ifdef _DEBUG
+    olc::Pixel DEBUG_COLOR;
+#endif
+
 public:
-    Entity(Debuggers* game_);
+    Entity(Debuggers* game, olc::Sprite* s);
     virtual ~Entity(){};
 
-    virtual void Update(float dt) = 0;
-    virtual void Draw() = 0;
+    virtual void Update(float dt);
+    virtual void Draw();
 
     float GetX() { return x; }
     float GetY() { return y; }
 
     bool Collides(Entity* entity);
     float Dist(Entity* entity) { return std::hypot(x - entity->x, y - entity->y); }
+
+    virtual bool IsActive();
+    virtual void ResetPosition();
+    virtual void Kill();
 };
 }
 

include/programmer.h

 
 class Programmer : public Entity {
 protected:
-    uint8_t tile = 0;
     uint32_t tileCounter = 0;
-    uint8_t skin = 0;
     bool onGround = false;
     bool doJump = false;
     bool walkLeft = false;
     virtual void Update(float dt) override;
     virtual void Draw() override;
     bool IsOnGround() { return onGround; }
-    uint8_t GetSkin() { return skin; }
-    void UpgradeLevel() { skin = std::min(skin + 1, 2); }
+    uint8_t GetSkin() { return tileX; }
+    void UpgradeLevel() { tileX = std::min(tileX + 1, tileCols - 1); }
 };
 }
 

src/bonus.cpp

+#include "bug.h"
+#include "debuggers.h"
+#include <iostream>
+#include <random>
+
+namespace pabloader {
+Bonus::Bonus(Debuggers* game)
+    : Entity(game, &game->bonusesSprite)
+{
+    tileCols = 1;
+    tileRows = 1;
+#ifdef _DEBUG
+    DEBUG_COLOR = olc::YELLOW;
+#endif
+}
+}

src/bug.cpp

 
 namespace pabloader {
 Bug::Bug(Debuggers* game)
-    : Entity(game)
-{
-    w = game->enemiesSprite.width / 4;
-    h = game->enemiesSprite.height / 4;
-}
-
-void Bug::Update(float dt)
-{
-    y += yv * dt;
-    yv += 30 * dt;
-
-    rotation += 3.14 / 8 * rotationSpeed * dt;
-
-    transform.Reset();
-    transform.Rotate(rotation);
-    transform.Translate(x, y);
-}
-
-void Bug::Draw()
+    : Entity(game, &game->enemiesSprite)
 {
+    tileCols = 1;
 #ifdef _DEBUG
-    game->DrawRect(x - w / 2, y - h / 2, w, h, olc::RED);
+    DEBUG_COLOR = olc::RED;
 #endif
-    olc::GFX2D::DrawPartialSprite(&game->enemiesSprite, 0, kind * h, w, h, transform, true);
-}
-
-bool Bug::IsActive()
-{
-    return y - h / 2 < game->GameScreenHeight();
-}
-
-void Bug::ResetPosition()
-{
-    y = -20 - std::rand() % game->ScreenHeight();
-    x = w + std::rand() % (game->ScreenWidth() - w * 2);
-    yv = 0;
-    kind = std::rand() % 4;
-    rotationSpeed = -8 + rand()%17;
-}
-
-void Bug::Kill()
-{
-    y = game->GameScreenHeight() + 100;
 }
 }

src/debuggers.cpp

         return false;
     }
 
+    // Load bonuses
+
+    fileName = "res/bonuses.pgs";
+    if (!bonusesSprite.LoadFromPGESprFile(fileName, &pack)) {
+        std::cerr << "[Load bonuses] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
     // Load background
 
     fileName = "res/bg.pgs";
         }
     }
 
+    Programmer* player = programmers.at(0);
+
+    for (auto& bonus : bonuses) {
+        if (bonus->IsActive()) {
+            bonus->Update(fElapsedTime);
+            bonus->Draw();
+            if (player->Collides(bonus)) {
+                // TODO add to inventory
+                bonus->Kill();
+            }
+        }
+    }
+
     linesOfCode = (sourceCode.size() * 4 / totalLines) + 1;
 
     for (auto it = programmers.rbegin(); it != programmers.rend(); it++) {
         programmer->Draw();
     }
 
-    Programmer* player = programmers.at(0);
-
     if (bugsSize == 0 && player->IsOnGround()) {
         SpawnBug();
     }
 
 #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()));
     if (GetKey(olc::B).bPressed) {
         SpawnBug();
     }
+    if (GetKey(olc::N).bPressed) {
+        SpawnBonus();
+    }
     if (GetKey(olc::P).bPressed) {
         SpawnProgrammer();
     }
     bug->ResetPosition();
 }
 
+void Debuggers::SpawnBonus()
+{
+    auto bonus = CreateBonus();
+    bonus->ResetPosition();
+}
+
 void Debuggers::SpawnProgrammer()
 {
     auto programmer = new Programmer(this);
     return bug;
 }
 
+Bonus* Debuggers::CreateBonus()
+{
+    for (auto bonus : bonuses) {
+        if (!bonus->IsActive())
+            return bonus;
+    }
+    auto bonus = new Bonus(this);
+    bonuses.push_back(bonus);
+    return bonus;
+}
+
 bool Debuggers::OnUserDestroy()
 {
     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 "entity.h"
+#include "debuggers.h"
 
 namespace pabloader {
-Entity::Entity(Debuggers* game)
+Entity::Entity(Debuggers* game, olc::Sprite* s): sprite(s), w(s->width / 4), h(s->height / 4)
 {
-    xv = 0;
-    yv = 0;
     Entity::game = game;
 }
 
+void Entity::Update(float dt)
+{
+    y += yv * dt;
+    yv += game->gravity * dt;
+
+    rotation += rotationSpeed * dt;
+
+    transform.Reset();
+    transform.Rotate(rotation);
+    transform.Translate(x, y);
+}
+
 bool Entity::Collides(Entity* entity)
 {
     bool collidesX = (x - w / 2 < entity->x + entity->w / 2) && (entity->x - entity->w / 2 < x + w / 2);
     return collidesX && collidesY;
 }
 
+void Entity::Draw()
+{
+#ifdef _DEBUG
+    game->DrawRect(x - w / 2, y - h / 2, w, h, DEBUG_COLOR);
+#endif
+    olc::GFX2D::DrawPartialSprite(sprite, tileX * w, tileY * h, w, h, transform, true);
+}
+
+bool Entity::IsActive()
+{
+    return y - h / 2 < game->GameScreenHeight();
+}
+
+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);
+    rotationSpeed = game->GetRandom(-3.14f, 3.14f);
+}
+
+void Entity::Kill()
+{
+    y = game->ScreenHeight() + 100;
+}
 }

src/player.cpp

 Player::Player(Debuggers* game)
     : Programmer(game)
 {
+#ifdef _DEBUG
+    DEBUG_COLOR = olc::BLUE;
+#endif
 }
 
 void Player::Think()
     // game->DrawString(1, 28, std::to_string(xv) + " " + std::to_string(yv));
 
     if (game->GetKey(olc::J).bPressed) {
-        skin = (skin + 1) % 4;
+        tileX = (tileX + 1) % tileCols;
     }
 #endif
 }

src/programmer.cpp

 
 namespace pabloader {
 Programmer::Programmer(Debuggers* game)
-    : Entity(game)
+    : Entity(game, &game->playerSprite)
 {
-    w = game->playerSprite.width / 4;
-    h = game->playerSprite.height / 4;
     x = (game->ScreenWidth() - w) / 2;
     y = h / 2;
+    tileCols = 3;
+
+#ifdef _DEBUG
+    DEBUG_COLOR = olc::GREEN;
+#endif
 }
 
 void Programmer::Think()
     xv *= 1 - 0.2 * dt;
 
     if (!onGround) {
-        yv += (70 + skin * 30) * dt;
+        yv += (70 + tileX * 30) * dt;
         yv *= 1 - 0.05 * dt;
     } else {
         xv *= 1 - dt;
     bool userInput = false;
 
     if (doJump && onGround) {
-        yv = -100 - 50 * skin;
+        yv = -100 - 50 * tileX;
         userInput = true;
     }
 
     if (walkLeft) {
-        xv -= (150 + skin * 50) * dt;
+        xv -= (150 + tileX * 50) * dt;
         userInput = true;
     }
 
     if (walkRight) {
-        xv += (150 + skin * 50) * dt;
+        xv += (150 + tileX * 50) * dt;
         userInput = true;
     }
 
     if (moveDown) {
         if (!onGround) {
-            yv += (150 + skin * 50) * dt;
+            yv += (150 + tileX * 50) * dt;
         }
         userInput = true;
     }
     onGround = newOnGround;
 
     if (onGround) {
-        tile = 2;
+        tileY = 2;
         tileCounter = static_cast<uint32_t>(0.1 / dt);
     } else if (tileCounter <= 0) {
-        tile = 0;
+        tileY = 0;
     } else {
         tileCounter--;
     }
 {
     int xOff = xv < 0 ? -1 : 0;
     if (std::abs(xv) < 1) {
-        olc::GFX2D::DrawPartialSprite(&game->playerSprite, skin * w + xOff, h + tile * h, w - xOff, h, transform, true);
+        olc::GFX2D::DrawPartialSprite(&game->playerSprite, tileX * w + xOff, h + tileY * h, w - xOff, h, transform, true);
     } else {
-        olc::GFX2D::DrawPartialSprite(&game->playerSprite, skin * w + xOff, 0 + tile * h, w - xOff, h, transform, true);
+        olc::GFX2D::DrawPartialSprite(&game->playerSprite, tileX * w + xOff, 0 + tileY * h, w - xOff, h, transform, true);
     }
 #ifdef _DEBUG
-    game->DrawRect(x - w / 2, y - h / 2, w, h, olc::GREEN);
+    game->DrawRect(x - w / 2, y - h / 2, w, h, DEBUG_COLOR);
 #endif
 }
 }