Music, main menu buttons

Makefile

 INCLUDES=-Iinclude -Ipge/include
 ifeq ($(OS),Windows_NT)
 	LIBRARIES=-luser32 -lgdi32 -lopengl32 -lgdiplus -lwinmm
-	EXECUTABLE=bin/debuggers.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=bin/debuggers
+	EXECUTABLE=debuggers
 	PACKER=packer/packer
 	CC=gcc
 	CPP=g++
 SPRITES=$(IMAGES:.png=.pgs)
 RESOURCES=$(SPRITES) $(wildcard res/*.wav) src/programmer.cpp
 
-PACK=bin/debuggers.pgp
+PACK=debuggers.pgp
 
 all: $(SOURCES) $(PACK) $(EXECUTABLE)
 

README.md

 # Make it!
 
 Just run `make` command to build
+
+# Info
+
+Music from https://filmmusic.io
+"Werq" by Kevin MacLeod (https://incompetech.com)
+License: CC BY (http://creativecommons.org/licenses/by/4.0/)

include/bonus.h

 namespace pabloader {
 
 enum BonusType {
-    BONUS_DEBUGGER = 0,
+    BONUS_DOCUMENTATION = 0,
     BONUS_UNIT_TEST = 1,
-    BONUS_DOCUMENTATION = 2
+    BONUS_DEBUGGER = 2
 };
 
 class Bonus : public Entity {

include/button.h

+#ifndef BUTTON_H
+#define BUTTON_H
+
+#include "olcPixelGameEngine.h"
+#include "game_state.h"
+
+#include <string>
+
+namespace pabloader {
+class Debuggers;
+typedef void (*ButtonAction)();
+class Button {
+public:
+    Button(Debuggers* game, int32_t x, int32_t y, int32_t w, int32_t h, std::string txt, GameState state);
+    void Draw();
+    void Update();
+    void SetText(std::string txt) { text = txt; }
+
+private:
+    Debuggers* game;
+    olc::vi2d pos;
+    olc::vi2d size;
+    std::string text;
+    GameState state;
+    bool hover = false;
+};
+}
+
+#endif

include/debuggers.h

 #include "olcPixelGameEngine.h"
 
 #include "bonus.h"
+#include "button.h"
 #include "bug.h"
 #include "player.h"
 #include "programmer.h"
+#include "game_state.h"
 
 #include <chrono>
 #include <list>
 #include <vector>
 
 namespace pabloader {
-enum GameState {
-    STATE_MAIN_MENU,
-    STATE_GAME,
-    STATE_PAUSE_MENU,
-    STATE_GAME_OVER,
-    STATE_HELP,
-    STATE_QUIT
-};
 
 class Debuggers : public olc::PixelGameEngine {
 private:
     std::list<Programmer*> programmers;
     std::list<Bonus*> bonuses;
+    std::list<Button*> buttons;
 
     std::map<BonusType, uint32_t> bonusesCatched;
 
     bool OnUserDestroy() override;
     int GameScreenHeight() { return ScreenHeight() - linesOfCode * 10; }
     GameState GetState() { return state; }
+    void SwitchState(GameState newState);
 
     template <typename T>
     T GetRandom(T from = 0, T to = 1);
 
 private:
     void ResetGame();
-    void SwitchState(GameState newState);
     void DrawMenu();
 
     void SpawnPlayer();
     olc::Sprite bonusesSprite;
     olc::Sprite backgroundSprite;
 
+    int bgMusic;
+
     int playerFallSample;
     int bugFallSample;
     int bugCatchSample;
+    int hoverSample;
+    int clickSample;
 
     const int gravity = 25;
 #ifdef _DEBUG

include/game_state.h

+#ifndef GAME_STATE_H
+#define GAME_STATE_H
+
+namespace pabloader {
+enum GameState {
+    STATE_MAIN_MENU,
+    STATE_GAME,
+    STATE_PAUSE_MENU,
+    STATE_GAME_OVER,
+    STATE_HELP,
+    STATE_QUIT
+};
+}
+
+#endif

pge/include/olcPGE_Common.h

 #endif
 
 #include <string>
+#include <cmath>
 
 namespace olc {
     enum rcode {

src/bonus.cpp

 Bonus::Bonus(Debuggers* game)
     : Entity(game, &game->bonusesSprite)
 {
-    tileDim = { 1, 3 };
+    tileDim = { 1, 1 };
 #ifdef _DEBUG
     DEBUG_COLOR = olc::YELLOW;
 #endif

src/button.cpp

+#include "button.h"
+#include "debuggers.h"
+
+namespace pabloader {
+Button::Button(Debuggers* game, int32_t x, int32_t y, int32_t w, int32_t h, std::string text, GameState state)
+    : game(game)
+    , pos(x, y)
+    , size(w, h)
+    , text(text)
+    , state(state)
+{
+}
+
+void Button::Update()
+{
+    auto x = game->GetMouseX();
+    auto y = game->GetMouseY();
+    auto newHover = x >= pos.x && x <= pos.x + size.x && y >= pos.y && y <= pos.y + size.y;
+    if (!hover && newHover) {
+        olc::SOUND::PlaySample(game->hoverSample);
+    }
+    hover = newHover;
+    if (hover && game->GetMouse(0).bPressed) {
+        olc::SOUND::PlaySample(game->clickSample);
+        game->SwitchState(state);
+    }
+}
+
+void Button::Draw()
+{
+    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);
+}
+}

src/debuggers.cpp

     }
 
     if (!pack.LoadPack("debuggers.pgp")) {
-        std::cerr << "Cannot load resource pack res/debuggers.pgp" << std::endl;
+        std::cerr << "Cannot load resource pack debuggers.pgp" << std::endl;
         return false;
     }
 
             originalSourceCode.push_back(line);
     }
 
+    fileName = "res/hover.wav";
+    hoverSample = olc::SOUND::LoadAudioSample(fileName, &pack);
+    if (hoverSample < 0) {
+        std::cerr << "[Load hover] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
+    fileName = "res/click.wav";
+    clickSample = olc::SOUND::LoadAudioSample(fileName, &pack);
+    if (clickSample < 0) {
+        std::cerr << "[Load click] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
+    fileName = "res/music.wav";
+    bgMusic = olc::SOUND::LoadAudioSample(fileName, &pack);
+    if (bgMusic < 0) {
+        std::cerr << "[Load music] File " << fileName << " is not found" << std::endl;
+        return false;
+    }
+
     totalLines = originalSourceCode.size();
 
     // Free Memory
 
     // Creating entities
 
+    buttons.push_back(new Button(this, ScreenWidth() / 2 - 64, 100, 128, 16, "Start", STATE_GAME));
+    buttons.push_back(new Button(this, ScreenWidth() / 2 - 64, 132, 128, 16, "Help", STATE_HELP));
+    buttons.push_back(new Button(this, ScreenWidth() / 2 - 64, 164, 128, 16, "Quit", STATE_QUIT));
+
     ResetGame();
     SwitchState(STATE_MAIN_MENU);
+    olc::SOUND::PlaySample(bgMusic, true);
 
     return true;
 }
     DrawString(ScreenWidth() - 128, 64, "by Pabloader");
     DrawString(ScreenWidth() - 17 * 8 - 2, ScreenHeight() - 10, "OLC Code Jam 2019");
 
-    std::string resumeText = state == STATE_PAUSE_MENU ? "continue" : "start";
+    std::string resumeText = state == STATE_PAUSE_MENU ? "Continue" : "Start";
+    if (buttons.size() > 0) {
+        buttons.front()->SetText(resumeText);
+    }
+
+    // DrawString(ScreenWidth() / 2 - 144, 100, "SPACE to " + resumeText + " game");
+    // DrawString(ScreenWidth() / 2 - 144, 116, "H to view help");
+    // DrawString(ScreenWidth() / 2 - 144, 132, "X to quit");
 
-    DrawString(ScreenWidth() / 2 - 144, 100, "SPACE to " + resumeText + " game");
-    DrawString(ScreenWidth() / 2 - 144, 116, "H to view help");
-    DrawString(ScreenWidth() / 2 - 144, 132, "X to quit");
+    for (auto& button : buttons) {
+        button->Update();
+        button->Draw();
+    }
 
     if (GetKey(olc::SPACE).bPressed || (GetKey(olc::ESCAPE).bPressed && state == STATE_PAUSE_MENU)) {
         SwitchState(STATE_GAME);