Mario: stop movement when entering main menu, check there was a movement before reversing it

mario/main.cpp

@@ -35,6 +35,8 @@ std::shared_ptr<SDLPP::TextRenderer> coins = nullptr;
 int coin_count = 0;
 int global_frames = 0;
 std::string last_load_level = "";
+bool __right_pressed = false;
+bool __left_pressed = false;
 
 std::vector<std::shared_ptr<MarioBlock>> moving_objects = {};
 std::vector<SceneStruct> game_scenes{};
@@ -46,10 +48,12 @@ void handleKeyDown(SDL_Keycode key, SDLPP::Scene &scene) {
     switch (key) {
     case SDLK_a:
     case SDLK_LEFT:
+        __left_pressed = true;
         mario->walkLeft();
         break;
     case SDLK_d:
     case SDLK_RIGHT:
+        __right_pressed = true;
         mario->walkRight();
         break;
     case SDLK_SPACE:
@@ -77,16 +81,26 @@ void handleKeyUp(SDL_Keycode key) {
     switch (key) {
     case SDLK_ESCAPE: {
         std::lock_guard<std::mutex> lock(render_mutex);
+        mario->setMovement(0, mario->getMovement().getY());
+        game_scenes.back().scene->pauseScene();
+        __right_pressed = false;
+        __left_pressed = false;
         game_scenes.push_back(
             createGameMainMenuScene(renderer, false, true, true));
     } break;
     case SDLK_a:
     case SDLK_LEFT:
-        mario->walkRight();
+        if (__left_pressed) {
+            mario->walkRight();
+            __left_pressed = false;
+        }
         break;
     case SDLK_d:
     case SDLK_RIGHT:
-        mario->walkLeft();
+        if (__right_pressed) {
+            mario->walkLeft();
+            __right_pressed = false;
+        }
         break;
     case SDLK_SPACE:
     case SDLK_w:

mario/scenes/game_main_menu.cpp

@@ -55,8 +55,9 @@ void resetGlobals() {
     __buttons_main_menu.clear();
 }
 
-void showLoadMenu(void */*UNUSED*/, Button */*UNUSED*/) {
+void showLoadMenu(void * /*UNUSED*/, Button * /*UNUSED*/) {
-    auto loadMenu = createLoadScene(__buttons_main_menu.back()->getRenderer(), "levels", loadLevel, false, false);
+    auto loadMenu = createLoadScene(__buttons_main_menu.back()->getRenderer(),
+                                    "levels", loadLevel, false, false);
     std::lock_guard<std::mutex> lock(render_mutex);
     game_scenes.pop_back();
     resetGlobals();
@@ -67,9 +68,9 @@ void __updateSelectedButton_MainMenu(uint64_t new_index) {
     if (new_index != (uint64_t)-1) {
         __buttons_main_menu[new_index]->setHighlight();
 
-        if (__cur_button_index_main_menu != (uint64_t)-1 && new_index != __cur_button_index_main_menu) {
+        if (__cur_button_index_main_menu != (uint64_t)-1 &&
-            __buttons_main_menu[__cur_button_index_main_menu]
+            new_index != __cur_button_index_main_menu) {
-                ->unsetHighlight();
+            __buttons_main_menu[__cur_button_index_main_menu]->unsetHighlight();
         }
         __cur_button_index_main_menu = new_index;
     }
@@ -78,7 +79,7 @@ void __updateSelectedButton_MainMenu(uint64_t new_index) {
 void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) {
     switch (key) {
     case SDLK_ESCAPE:
-        if(__include_resume) {
+        if (__include_resume) {
             resumeMainMenu();
         } else {
             quitMainMenu();
@@ -86,7 +87,7 @@ void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) {
         break;
     case SDLK_DOWN:
     case SDLK_s:
-        if(__cur_button_index_main_menu == __buttons_main_menu.size() - 1) {
+        if (__cur_button_index_main_menu == __buttons_main_menu.size() - 1) {
             __updateSelectedButton_MainMenu(0);
         } else {
             __updateSelectedButton_MainMenu(__cur_button_index_main_menu + 1);
@@ -94,14 +95,15 @@ void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) {
         break;
     case SDLK_UP:
     case SDLK_w:
-        if(__cur_button_index_main_menu == 0) {
+        if (__cur_button_index_main_menu == 0) {
             __updateSelectedButton_MainMenu(__buttons_main_menu.size() - 1);
         } else {
             __updateSelectedButton_MainMenu(__cur_button_index_main_menu - 1);
         }
         break;
     case SDLK_RETURN:
-        if(__cur_button_index_main_menu >= 0 && __cur_button_index_main_menu < __buttons_main_menu.size()) {
+        if (__cur_button_index_main_menu >= 0 &&
+            __cur_button_index_main_menu < __buttons_main_menu.size()) {
             __buttons_main_menu[__cur_button_index_main_menu]
                 ->performFunction();
         }
@@ -112,10 +114,13 @@ void handleKeyUpMainMenu(SDL_Keycode key, SDLPP::Scene & /*UNUSED*/) {
 }
 
 std::shared_ptr<SDLPP::Scene>
-createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer, bool include_restart, bool include_resume, bool transparent_bg) {
+createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer,
+                    bool include_restart, bool include_resume,
+                    bool transparent_bg) {
     auto scene = std::make_shared<SDLPP::Scene>(renderer);
-    auto bg = std::make_shared<SDLPP::RectangleRender>(0, 0, 10, 10, renderer,
+    auto bg = std::make_shared<SDLPP::RectangleRender>(
-                                                       transparent_bg ? "#00000088" : MARIO_OVERWORLD_COLORKEY, true);
+        0, 0, 10, 10, renderer,
+        transparent_bg ? "#00000088" : MARIO_OVERWORLD_COLORKEY, true);
     bg->setPermanent();
     bg->setId(1);
     scene->addObject(bg);
@@ -141,27 +146,29 @@ createSceneMainMenu(std::shared_ptr<SDLPP::Renderer> &renderer, bool include_res
     default_button_theme.font_outline_color_disabled = "#787878";
     default_button_theme.outline = 0.1;
     // buttons
-    if(include_resume) {
+    if (include_resume) {
         __buttons_main_menu.emplace_back(std::make_shared<Button>(
             0.2, 0.25, 0.6, 0.1, renderer, "RESUME", default_button_theme,
             resumeMainMenuCallback, nullptr));
         __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
-                                                SDLPP::OBJ_CENTER);
+                                                 SDLPP::OBJ_CENTER);
         __buttons_main_menu.back()->setPermanent();
-        __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
+        __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() -
+                                                   1);
     }
-    if(include_restart || include_resume) {
+    if (include_restart || include_resume) {
         __buttons_main_menu.emplace_back(std::make_shared<Button>(
             0.2, 0.4, 0.6, 0.1, renderer, "RESTART", default_button_theme,
             restartMainMenuCallback, nullptr));
         __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
-                                                SDLPP::OBJ_CENTER);
+                                                 SDLPP::OBJ_CENTER);
         __buttons_main_menu.back()->setPermanent();
-        __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() - 1);
+        __buttons_main_menu.back()->setButtonIndex(__buttons_main_menu.size() -
+                                                   1);
     }
-    __buttons_main_menu.emplace_back(std::make_shared<Button>(
+    __buttons_main_menu.emplace_back(
-        0.2, 0.55, 0.6, 0.1, renderer, "LOAD", default_button_theme,
+        std::make_shared<Button>(0.2, 0.55, 0.6, 0.1, renderer, "LOAD",
-        showLoadMenu, nullptr));
+                                 default_button_theme, showLoadMenu, nullptr));
     __buttons_main_menu.back()->setAlignment(SDLPP::OBJ_CENTER,
                                              SDLPP::OBJ_CENTER);
     __buttons_main_menu.back()->setPermanent();
@@ -192,7 +199,8 @@ void additionalRenderMainMenu(std::shared_ptr<SDLPP::Scene> & /*UNUSED*/) {
     }
     if (__quit_scenes_main_menu) {
         game_scenes.pop_back();
-        if(__restart_scenes_main_menu) {
+        game_scenes.back().scene->unpauseScene();
+        if (__restart_scenes_main_menu) {
             loadLastLevel();
         }
         resetGlobals();
@@ -246,11 +254,13 @@ void pollEventsMainMenu(std::shared_ptr<SDLPP::Scene> &scene) {
     }
 }
 
-SceneStruct
+SceneStruct createGameMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer,
-createGameMainMenuScene(std::shared_ptr<SDLPP::Renderer> &renderer, bool include_restart, bool include_resume, bool transparent_background) {
+                                    bool include_restart, bool include_resume,
+                                    bool transparent_background) {
     __include_resume = include_resume;
     SceneStruct ret{};
-    ret.scene = createSceneMainMenu(renderer, include_restart, include_resume, transparent_background);
+    ret.scene = createSceneMainMenu(renderer, include_restart, include_resume,
+                                    transparent_background);
     ret.additionalRender = additionalRenderMainMenu;
     ret.doInput = pollEventsMainMenu;
     __update_scenes_main_menu = true;

sdlpp/sdlpp_scene.cpp

@@ -90,6 +90,9 @@ Scene::getObjects( const std::unordered_set< int > &objectIDs ) {
     return ret;
 }
 void Scene::updateScene() {
+    if(paused) {
+        return;
+    }
     // check for objects that should be removed
     checkKilled();
     std::lock_guard< std::mutex > lock( render_mutex );
@@ -102,6 +105,14 @@ void Scene::updateScene() {
     }
     prev_ticks = now_ticks;
 }
+void Scene::pauseScene() {
+    paused = true;
+    diff_ticks = SDL_GetTicks() - prev_ticks;
+}
+void Scene::unpauseScene() {
+    paused = false;
+    prev_ticks = SDL_GetTicks() - diff_ticks;
+}
 std::vector< std::pair< uint64_t, std::shared_ptr< RenderObject > > >
 Scene::getCollisions( RenderObject &r ) {
     if ( r.getHidden() )

sdlpp/sdlpp_scene.hpp

@@ -28,6 +28,8 @@ public:
     std::vector< std::shared_ptr< RenderObject > >
     getObjects( const std::unordered_set< int > &objectIDs );
     void updateScene();
+    void pauseScene();
+    void unpauseScene();
     std::vector< std::pair< uint64_t, std::shared_ptr< RenderObject > > >
     getCollisions( RenderObject &r );
     void visitCollisions( RenderObject &r, Visitor &v );
@@ -63,12 +65,14 @@ private:
     std::shared_ptr< Renderer > renderer;
     std::shared_ptr< Texture > background;
     int prev_ticks = 0;
+    int diff_ticks = 0;
     std::shared_ptr< RenderObject > leftmost_obj;
     std::shared_ptr< RenderObject > rightmost_obj;
     uint64_t max_object_id = 0;
     std::mutex render_mutex;
     std::unordered_set<uint64_t> background_ids;
     uint64_t first_non_background_index = 1;
+    bool paused = false;
 };
 } // end of namespace SDLPP
 #endif