Help Screen

TODO.md

 
  - [x] Main menu
  - [x] Pause (ESC) menu
-   - [ ] Mouse menu
- - [ ] Help screen
+   - [x] Mouse menu
+ - [x] Help screen
 
  - [ ] ~~Bugs only catchable by 2 programmers~~
  - [ ] ~~Bugs only catchable with debugger~~

include/button.h

 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();
+    bool Update();
     void SetText(std::string txt) { text = txt; }
 
 private:

include/debuggers.h

     std::list<std::string> sourceCode;
 
     GameState state = STATE_MAIN_MENU;
+    GameState prevState;
+    float helpRotation = 0;
 
     std::mt19937 generator;
 
 
 private:
     void ResetGame();
+    void ClearButtons();
     void DrawMenu();
+    void DrawSourceCode();
+    void DrawLogo();
 
     void SpawnPlayer();
     void SpawnProgrammer();

src/bug.cpp

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

src/button.cpp

 {
 }
 
-void Button::Update()
+bool Button::Update()
 {
     auto x = game->GetMouseX();
     auto y = game->GetMouseY();
     if (hover && game->GetMouse(0).bPressed) {
         olc::SOUND::PlaySample(game->clickSample);
         game->SwitchState(state);
+        return true;
     }
+    return false;
 }
 
 void Button::Draw()

src/debuggers.cpp

 
     // 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);
         debug = !debug;
     }
 #endif
+    bool result = false;
     switch (state) {
     case STATE_GAME:
     case STATE_MAIN_MENU:
-        return GamePlay(fElapsedTime);
+        result = GamePlay(fElapsedTime);
+        break;
     case STATE_PAUSE_MENU:
-        return PauseMenu(fElapsedTime);
+        result = PauseMenu(fElapsedTime);
+        break;
+    case STATE_HELP:
+        result = HelpMenu(fElapsedTime);
+        break;
     case STATE_GAME_OVER:
-        return GameOver(fElapsedTime);
+        result = GameOver(fElapsedTime);
+        break;
     default:
-        return false;
+        break;
     }
+
+    for (auto& button : buttons) {
+        button->Draw();
+        if (button->Update()) {
+            break;
+        }
+    }
+    return result;
 }
 
 void Debuggers::DrawMenu()
 {
-    SetPixelMode(olc::Pixel::ALPHA);
-    FillRect(0, 0, ScreenWidth(), ScreenHeight(), { 0, 0, 0, 160 });
-    SetPixelMode(olc::Pixel::NORMAL);
-
-    DrawString(ScreenWidth() / 2 - 144, 32, "DEBUGGERS", olc::YELLOW, 4);
-    DrawString(ScreenWidth() - 128, 64, "by Pabloader");
-    DrawString(ScreenWidth() - 17 * 8 - 2, ScreenHeight() - 10, "OLC Code Jam 2019");
+    DrawLogo();
 
     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");
-
-    for (auto& button : buttons) {
-        button->Update();
-        button->Draw();
-    }
-
-    if (GetKey(olc::SPACE).bPressed || (GetKey(olc::ESCAPE).bPressed && state == STATE_PAUSE_MENU)) {
+    if (GetKey(olc::ESCAPE).bPressed && state == STATE_PAUSE_MENU) {
         SwitchState(STATE_GAME);
     }
+}
 
-    if (GetKey(olc::H).bPressed) {
-        SwitchState(STATE_HELP);
+void Debuggers::DrawSourceCode()
+{
+    int y = GameScreenHeight();
+    FillRect(0, y - 1, ScreenWidth(), ScreenHeight() - y + 1, olc::VERY_DARK_GREY);
+
+    for (auto& line : sourceCode) {
+        DrawString(1, y, line);
+        y += 10;
+        if (y >= ScreenHeight())
+            break;
     }
+}
 
-    if (GetKey(olc::X).bPressed) {
-        SwitchState(STATE_QUIT);
-    }
+void Debuggers::DrawLogo()
+{
+    SetPixelMode(olc::Pixel::ALPHA);
+    FillRect(0, 0, ScreenWidth(), ScreenHeight(), { 0, 0, 0, 128 });
+    SetPixelMode(olc::Pixel::NORMAL);
+
+    DrawString(ScreenWidth() / 2 - 144, 32, "DEBUGGERS", olc::YELLOW, 4);
+    DrawString(ScreenWidth() - 128, 64, "by Pabloader");
+    DrawString(ScreenWidth() - 17 * 8 - 2, ScreenHeight() - 10, "OLC Code Jam 2019");
 }
 
 void Debuggers::SwitchState(GameState newState)
 {
+    prevState = state;
+    ClearButtons();
     switch (newState) {
     case STATE_GAME:
         if (state == STATE_MAIN_MENU || state == STATE_GAME_OVER) {
     case STATE_MAIN_MENU:
         ResetGame();
         SpawnProgrammer();
+        // fallthrough
+    case STATE_PAUSE_MENU:
+        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));
+        break;
+    case STATE_HELP:
+        buttons.push_back(new Button(this, 16, 64, 64, 16, "Back", prevState));
         break;
     default:
         break;
 
 void Debuggers::ResetGame()
 {
+    ClearButtons();
     for (auto& i : programmers) {
         delete i;
     }
     sourceCode = originalSourceCode;
 }
 
+void Debuggers::ClearButtons()
+{
+    for (auto& i : buttons) {
+        delete i;
+    }
+    buttons.clear();
+}
+
 void Debuggers::SpawnBug()
 {
     auto bug = CreateBug();

src/debuggers_states.cpp

     }
 #endif
     if (state == STATE_GAME) {
-        DrawString(1, 1, "A,S,D - move; SPACE - jump", olc::CYAN);
-        DrawString(1, 10, "Don't let the bugs destroy your code!", olc::YELLOW);
-        DrawString(1, 19, "Bugs catched: " + std::to_string(bugsCatched));
-        DrawString(1, 28, "Bugs missed: " + std::to_string(bugsMissed));
+        DrawString(1, 1, "Don't let the bugs destroy your code!", olc::YELLOW);
+        DrawString(1, 10, "Bugs catched: " + std::to_string(bugsCatched));
+        DrawString(1, 19, "Bugs missed: " + std::to_string(bugsMissed));
     }
 
-    int y = GameScreenHeight();
-    FillRect(0, y - 1, ScreenWidth(), ScreenHeight() - y + 1, olc::VERY_DARK_GREY);
-
-    for (auto& line : sourceCode) {
-        DrawString(1, y, line);
-        y += 10;
-        if (y >= ScreenHeight())
-            break;
-    }
+    DrawSourceCode();
 
     if (state == STATE_MAIN_MENU) {
         DrawMenu();
         programmer->Draw();
     }
 
-    int y = GameScreenHeight();
-    FillRect(0, y - 1, ScreenWidth(), ScreenHeight() - y + 1, olc::VERY_DARK_GREY);
-
-    for (auto& line : sourceCode) {
-        DrawString(1, y, line);
-        y += 10;
-        if (y >= ScreenHeight())
-            break;
-    }
-
+    DrawSourceCode();
     DrawMenu();
 
     return true;
     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) {
         SwitchState(STATE_MAIN_MENU);
     }
 
     return true;
 }
+
+bool Debuggers::HelpMenu(float dt)
+{
+    DrawSprite(0, 0, &backgroundSprite);
+    DrawSourceCode();
+    DrawLogo();
+
+    auto y = 96;
+
+    DrawString(16, y, "A,S,D - move left/down/right");
+    y += 9;
+    DrawString(16, y, "SPACE - jump");
+    y += 9;
+    DrawString(16, y, "Bugs, you must destroy them: ");
+    y += 9;
+
+    helpRotation += dt;
+    auto w = enemiesSprite.width / 4;
+    auto h = enemiesSprite.height / 4;
+
+    y += h;
+
+    olc::GFX2D::Transform2D transform;
+    transform.Scale(2, 2);
+    transform.Rotate(helpRotation);
+    transform.Translate(16 + w / 2, y);
+
+    SetPixelMode(olc::Pixel::MASK);
+    for (auto i = 0; i < 2; i++) {
+        for (auto j = 0; j < 4; j++) {
+            olc::GFX2D::DrawPartialSprite(&enemiesSprite, i * w, j * h, w, h, transform, true);
+            transform.Translate(w * 2, 0);
+        }
+    }
+    y += h;
+    w = bonusesSprite.width / 4;
+    h = bonusesSprite.height / 4;
+
+    DrawString(16, y, "RTFM removes 10% bugs: ");
+    y += 9 + h / 2;
+
+    DrawPartialSprite(16 + w / 2, y, &bonusesSprite, 0, 0, w, h, 1, true);
+
+    SetPixelMode(olc::Pixel::NORMAL);
+
+    if (GetKey(olc::ESCAPE).bPressed) {
+        SwitchState(prevState);
+    }
+
+    return true;
+}
 }