Particles

include/bug.h

 
 namespace pabloader {
 class Bug : public Entity {
+    friend class BugParticle;
 public:
     Bug(Debuggers* game);
 };
+
+class BugParticle: public Entity {
+public:
+    BugParticle(Debuggers* game);
+    void ResetParticle(Bug* bug, uint8_t index);
+};
+
 }
 
 #endif

include/debuggers.h

     std::list<Bonus*> bonuses;
     std::list<Button*> buttons;
 
+    std::list<BugParticle*> particles;
+
     std::map<BonusType, uint32_t> bonusesCatched;
 
     uint32_t bugsCatched = 0;
     void SpawnPlayer();
     void SpawnProgrammer();
     void SpawnBug();
+    void SpawnBugParticles(Bug* bug);
     void SpawnBonus();
     Bug* CreateBug();
+    BugParticle* CreateBugParticle();
     Bonus* CreateBonus();
 
 private: // Gamemodes
     int hoverSample;
     int clickSample;
 
-    const int gravity = 25;
+    const int gravity = 20;
 #ifdef _DEBUG
     bool debug = false;
 #endif

src/bug.cpp

     DEBUG_COLOR = olc::RED;
 #endif
 }
+
+BugParticle::BugParticle(Debuggers* game)
+    : Entity(game, &game->enemiesSprite)
+{
+    size.x = sprite->width / 8;
+    size.y = sprite->height / 8;
+#ifdef _DEBUG
+    DEBUG_COLOR = olc::MAGENTA;
+#endif
+}
+
+void BugParticle::ResetParticle(Bug* bug, uint8_t index)
+{
+    vel.x = bug->vel.x + ((index & 0b01) ? 10: -10);
+    vel.y = bug->vel.y + ((index & 0b10) ? 10: -10);
+
+    pos = bug->pos;
+
+    rotation = bug->rotation;
+
+    tile.x = bug->tile.x * 2 + ((index & 0b01) ? 1: 0);
+    tile.y = bug->tile.y * 2 + ((index & 0b10) ? 1: 0);
+}
 }

src/button.cpp

     auto sw = 8 * text.size();
     auto sh = 8;
     game->DrawRect(pos.x, pos.y, size.x, size.y, hover ? olc::WHITE : olc::GREY);
-    game->DrawString(pos.x + (size.x - sw) / 2, pos.y + (size.y - sh) / 2, text);
+    game->DrawString(pos.x + (size.x - sw) / 2, pos.y + (size.y - sh) / 2, text, hover ? olc::WHITE : olc::GREY);
 }
 }

src/debuggers.cpp

     if (buttons.size() > 0) {
         buttons.front()->SetText(resumeText);
     }
-
-    if (GetKey(olc::ESCAPE).bPressed && state == STATE_PAUSE_MENU) {
-        SwitchState(STATE_GAME);
-    }
 }
 
 void Debuggers::DrawSourceCode()
     case STATE_HELP:
         buttons.push_back(new Button(this, 16, 64, 64, 16, "Back", prevState));
         break;
+    case STATE_GAME_OVER:
+        buttons.push_back(new Button(this, ScreenWidth() / 2 - 64, ScreenHeight() / 2 + 40, 128, 16, "Try again", STATE_GAME));
+        buttons.push_back(new Button(this, ScreenWidth() / 2 - 64, ScreenHeight() / 2 + 72, 128, 16, "Main menu", STATE_MAIN_MENU));
+        break;
     default:
         break;
     }
     bug->ResetPosition();
 }
 
+void Debuggers::SpawnBugParticles(Bug* bug)
+{
+    for (auto i = 0; i < 4; i++) {
+        auto particle = CreateBugParticle();
+        particle->ResetPosition();
+        particle->ResetParticle(bug, i);
+    }
+}
+
 void Debuggers::SpawnBonus()
 {
     auto bonus = CreateBonus();
     return bug;
 }
 
+BugParticle* Debuggers::CreateBugParticle()
+{
+    for (auto particle : particles) {
+        if (!particle->IsActive() || !particle->IsAlive())
+            return particle;
+    }
+    auto particle = new BugParticle(this);
+    particles.push_back(particle);
+    return particle;
+}
+
 Bonus* Debuggers::CreateBonus()
 {
     for (auto bonus : bonuses) {

src/debuggers_states.cpp

 
 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();
                     if (programmer == player) {
                         bugsCatchedByPlayer++;
                     }
+                    SpawnBugParticles(bug);
                     bug->Kill();
                     if (state == STATE_GAME)
                         olc::SOUND::PlaySample(bugCatchSample);
         }
     }
 
+    for (auto& particle : particles) {
+        if (particle->IsInScreen()) {
+            particle->Update(fElapsedTime);
+            particle->Draw();
+        } else {
+            particle->Kill();
+        }
+    }
+
     for (auto& bonus : bonuses) {
         if (bonus->IsActive()) {
             bonus->Update(fElapsedTime);
                     if (aliveBugs > 1) {
                         for (auto& bug : bugs) {
                             if (bug->IsAlive() && bug->IsActive()) {
+                                SpawnBugParticles(bug);
                                 bug->Kill();
                                 break;
                             }
 
     if (state == STATE_MAIN_MENU) {
         DrawMenu();
+    } else if (state == STATE_GAME) {
+        if (!IsFocused() || GetKey(olc::ESCAPE).bPressed) {
+            SwitchState(STATE_PAUSE_MENU);
+        } else if (sourceCode.size() == 0) {
+            SwitchState(STATE_GAME_OVER);
+        }
     }
 
     return true;
         }
     }
 
+    for (auto& particle : particles) {
+        if (particle->IsInScreen()) {
+            particle->Draw();
+        }
+    }
+
     for (auto& bonus : bonuses) {
         if (bonus->IsActive()) {
             bonus->Draw();
     DrawSourceCode();
     DrawMenu();
 
+    if (GetKey(olc::ESCAPE).bPressed) {
+        SwitchState(STATE_GAME);
+    }
+
     return true;
 }
 
     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");
-
-    // TODO main menu
 
-    if (GetKey(olc::SPACE).bPressed) {
+    if (GetKey(olc::ESCAPE).bPressed) {
         SwitchState(STATE_MAIN_MENU);
     }