Create falling bugs

include/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";
-        player = new Player(this);
     }
 
     ~Awoorwae()
     bool OnUserUpdate(float fElapsedTime) override;
     bool OnUserDestroy() override;
 
+private:
+    Bug* SpawnBug();
+
 public:
     olc::ResourcePack pack;
+    olc::Sprite playerSprite;
+    olc::Sprite enemiesSprite;
+    int playerFallSample;
 };
 }
 

include/bug.h

+#ifndef BUG_H
+#define BUG_H
+
+#include "entity.h"
+
+namespace pabloader {
+class Bug : public Entity {
+public:
+    Bug(Awoorwae* game);
+    void Update(float dt) override;
+    void Draw() override;
+    bool IsActive();
+    void ResetPosition();
+
+private:
+    int kind = 0;
+};
+}
+
+#endif

include/entity.h

 class Entity {
 protected:
     Awoorwae* game;
-    olc::Sprite img;
     olc::GFX2D::Transform2D transform;
     float x, y;
     float xv, yv;
     int w, h;
-    int tile = 0;
-    int skin = 0;
-    int tileCounter = 0;
-    bool onGround = false;
 
 public:
     Entity(Awoorwae* game_);
     virtual ~Entity(){};
-
-    virtual olc::rcode Load() = 0;
+    
     virtual void Update(float dt) = 0;
     virtual void Draw() = 0;
+    bool Collides(Entity* entity);
 };
 }
 

include/player.h

 
 #include "entity.h"
 #include "olcPGE_Common.h"
-#include "olcPGEX_Sound.h"
 
 namespace pabloader {
 
 class Player : public Entity {
 public:
     Player(Awoorwae* game);
-    olc::rcode Load() override;
     void Update(float dt) override;
     void Draw() override;
 
 private:
-    int fallSample;
+    int tile = 0;
+    int skin = 0;
+    int tileCounter = 0;
+    bool onGround = false;
 };
 }
 

src/awoorwae.cpp

 
 bool Awoorwae::OnUserCreate()
 {
+    SetPixelMode(olc::Pixel::MASK);
+    
     if (!olc::SOUND::InitialiseAudio()) {
         std::cerr << "Cannot init audio" << std::endl;
         return false;
         return false;
     }
 
-    if (!player->Load())
+    // 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;
+    }
 
-    SetPixelMode(olc::Pixel::MASK);
+    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;
 }
 
 
     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;
 }
 
     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 <iostream>
+#include <random>
+
+namespace pabloader {
+Bug::Bug(Awoorwae* game_)
+    : Entity(game_)
+{
+    w = game->enemiesSprite.width / 4;
+    h = game->enemiesSprite.height / 4;
+}
+
+void Bug::Update(float dt)
+{
+    y += yv * dt;
+    yv += 50 * dt;
+}
+
+void Bug::Draw()
+{
+#ifdef _DEBUG
+    game->DrawRect(x, y, w, h, olc::RED);
+#endif
+    game->DrawPartialSprite(x, y, &game->enemiesSprite, 0, kind * h, w, h);
+}
+
+bool Bug::IsActive()
+{
+    return y < game->ScreenHeight();
+}
+
+void Bug::ResetPosition()
+{
+    y = -20;
+    x = w + std::rand() % (game->ScreenWidth() - w * 2);
+    yv = 0;
+    kind = std::rand() % 4;
+}
+}

src/entity.cpp

 #include "entity.h"
 
 namespace pabloader {
-Entity::Entity(Awoorwae* game_)
-    : game(game_)
+Entity::Entity(Awoorwae* game)
 {
     xv = 0;
     yv = 0;
+    Entity::game = game;
+}
+
+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);
+    return collidesX && collidesY;
 }
 }

src/player.cpp

 #include "player.h"
 #include "awoorwae.h"
+#include "olcPGEX_Sound.h"
 #include <iostream>
 
 namespace pabloader {
 Player::Player(Awoorwae* game_)
     : Entity(game_)
 {
-}
-
-olc::rcode Player::Load()
-{
-    const std::string spriteFile = "res/player.pgs";
-    const std::string fallFile = "res/fall.wav";
-    if (img.LoadFromPGESprFile(spriteFile, &game->pack)) {
-        w = img.width / 4;
-        h = img.height / 4;
-        x = (game->ScreenWidth() - w) / 2;
-        y = game->ScreenHeight() / 2;
-    } else {
-        std::cerr << "File " << spriteFile << " is not found" << std::endl;
-        return olc::FAIL;
-    }
-    fallSample = olc::SOUND::LoadAudioSample(fallFile, &game->pack);
-    if (fallSample < 0) {
-        std::cerr << "File " << fallFile << " is not found" << std::endl;
-        return olc::FAIL;
-    }
-
-    return olc::OK;
+    w = game->playerSprite.width / 4;
+    h = game->playerSprite.height / 4;
+    x = (game->ScreenWidth() - w) / 2;
+    y = game->ScreenHeight() / 2;
 }
 
 void Player::Update(float dt)
 
 #ifdef _DEBUG
     game->DrawString(1, 10, std::to_string(x) + " " + std::to_string(y));
-    game->DrawString(1, 18, std::to_string(xv) + " " + std::to_string(yv));
+    game->DrawString(1, 19, std::to_string(xv) + " " + std::to_string(yv));
 #endif
     bool userInput = false;
 
     if (x > game->ScreenWidth() - w / 2) {
         xv *= -0.3;
         x = game->ScreenWidth() - w / 2;
-        olc::SOUND::PlaySample(fallSample);
+        olc::SOUND::PlaySample(game->playerFallSample);
     }
 
     if (x < w / 2) {
         xv *= -0.3;
         x = w / 2;
-        olc::SOUND::PlaySample(fallSample);
+        olc::SOUND::PlaySample(game->playerFallSample);
     }
 
     if (y > game->ScreenHeight() - h / 2) {
 
     bool newOnGround = y >= game->ScreenHeight() - h / 2;
     if (newOnGround && !onGround) {
-        olc::SOUND::PlaySample(fallSample);
+        olc::SOUND::PlaySample(game->playerFallSample);
     }
     onGround = newOnGround;
 
 {
     int xOff = xv < 0 ? -1 : 0;
     if (std::abs(xv) < 1) {
-        olc::GFX2D::DrawPartialSprite(&img, skin * w + xOff, h + tile * h, w, h, transform, true);
+        olc::GFX2D::DrawPartialSprite(&game->playerSprite, skin * w + xOff, h + tile * h, w, h, transform, true);
     } else {
-        olc::GFX2D::DrawPartialSprite(&img, skin * w + xOff, 0 + tile * h, w, h, transform, true);
+        olc::GFX2D::DrawPartialSprite(&game->playerSprite, skin * w + xOff, 0 + tile * h, w, h, transform, true);
     }
 #ifdef _DEBUG
     float x, y;