Feat implemented 3 working and functional menus: pauseMenu, startingS…

…creenMenu and gameOverMenu

libs/CollisionResolver.cpp

@@ -22,10 +22,9 @@ void CollisionResolver::handlePlayerCollisionWithPrincess() const {
     }
 }
 
-void CollisionResolver::handlePlayerCollisionWithBarrel(std::shared_ptr<Barrel> barrel, bool* quit, GameTime* gameTime) const{
+void CollisionResolver::handlePlayerCollisionWithBarrel(std::shared_ptr<Barrel> barrel, GameState* gameState) const{
     if (CollisionDetector::isCollisionBetweenRects(gameObjectContainer->player->destRect, barrel->destRect)) {
-        *quit = true;
-		gameTime->pause();
+		*gameState = GameState::GAME_OVER;
     }
 }
 
@@ -68,11 +67,11 @@ void CollisionResolver::handlePlayerCollision() {
     }
 }
 
-void CollisionResolver::handleBarrelsCollision(bool* quit, GameTime* gameTime) {
+void CollisionResolver::handleBarrelsCollision(GameState* gameState) {
     for (int i = 0; i < gameObjectContainer->barrelContainer->getNumberOfElements(); i++) {
         auto barrel = gameObjectContainer->barrelContainer->barrels[i];
 
-        handlePlayerCollisionWithBarrel(barrel, quit, gameTime);
+        handlePlayerCollisionWithBarrel(barrel, gameState);
         handleCollisionWithPlatform(barrel);
 
         if (CollisionDetector::isGameObjectOnTopOfAnyPlatform(barrel, gameObjectContainer->platformContainer)) {

libs/CollisionResolver.h

@@ -2,6 +2,7 @@
 #include "MovableGameObject.h"
 #include "GameObjectContainer.h"
 #include "GameTime.h"
+#include "GameState.h"
 
 
 class CollisionResolver {
@@ -13,12 +14,12 @@ class CollisionResolver {
 
     void handlePlayerCollisionWithKong() const;
     void handlePlayerCollisionWithPrincess() const;
-    void handlePlayerCollisionWithBarrel(std::shared_ptr<Barrel> barrel, bool* quit, GameTime* gameTime) const;
+    void handlePlayerCollisionWithBarrel(std::shared_ptr<Barrel> barrel, GameState* gameState) const;
     void handleCollisionWithPlatform(const std::shared_ptr<MovableGameObject>& gameObject);
     void handleCollisionWithJumping();
 
     void handlePlayerCollision();
-    void handleBarrelsCollision(bool* openGameOverMenu, GameTime* gameTime);
+    void handleBarrelsCollision(GameState* gameState);
 
     [[noreturn]] void closeGame() const;
 };

libs/Game.cpp

@@ -1,7 +1,7 @@
 #include "Game.h"
 
 Game::Game()
-    : gameState(GameState::RUNNING),
+    : gameState(GameState::START),
     gameTime(GameTime()),
     gameObjectContainer(std::make_unique<GameObjectContainer>()),
     screenManager(ScreenManager(gameObjectContainer)),
@@ -11,7 +11,7 @@ Game::Game()
     pauseMenu(Menu(SCREEN_WIDTH - ((640 * 0.75) / 2), (SCREEN_HEIGHT - 480 * 0.75) / 2, 640 * 0.75, 480 * 0.75, 3, { "Resume", "Leaderboard", "Quit" })),
     gameOverMenu(Menu(SCREEN_WIDTH - ((640 * 0.75) / 2), (SCREEN_HEIGHT - 480 * 0.75) / 2, 640 * 0.75, 480 * 0.75, 3, { "Retry", "Quit" })),
     gameObjectManager(GameObjectManager(gameObjectContainer)),
-    keyActionHandler(KeyActionHandler(&keyCollector.pressedKeys, &keyCollector.releasedKeys, &gameTime, gameObjectContainer.get(), &pauseMenu, &gameState)) {
+    keyActionHandler(KeyActionHandler(&keyCollector.pressedKeys, &keyCollector.releasedKeys, &gameTime, gameObjectContainer.get(), &pauseMenu, &gameOverMenu, &startingScreenMenu, &gameState)) {
     startGame();
 }
 
@@ -42,12 +42,13 @@ Game::Game()
         keyActionHandler.handleInput();
 
         switch (gameState) {
-            //case GameState::START:
-            //    gameTime.pause();
-            //    screenManager.drawMenu(startingScreenMenu);
-            //    break;
+            case GameState::START:
+                gameTime.pause();
+                screenManager.drawMenu(startingScreenMenu);
+                break;
 
             case GameState::PAUSE:
+				gameTime.pause();
                 screenManager.drawMenu(pauseMenu);
                 break;
 
@@ -56,16 +57,12 @@ Game::Game()
                 break;
 
             case GameState::RUNNING:
-                if (gameTime.isPaused) {
-                    gameTime.resume();
-                }
 
-                // UPDATE TIME
+                gameTime.resume();
                 gameTime.update();
 
-                // UPDATE GAMEOBJECTS
                 gameObjectManager.updatePositionOfGameObjects(gameTime.deltaTime);
-                gameObjectManager.handleCollisionsOfGameObjects(quit, &gameTime);
+                gameObjectManager.handleCollisionsOfGameObjects(&gameState);
                 gameObjectManager.updatePhysicsOfGameObjects(gameTime.deltaTime);
                 gameObjectContainer->donkeyKong->update(gameTime.deltaTime);
 

libs/GameObjectManager.cpp

@@ -13,9 +13,9 @@ void GameObjectManager::updatePositionOfGameObjects(double deltaTime) {
 	gameObjectContainer->barrelContainer->updateBarrels(deltaTime);
 }
 
-void GameObjectManager::handleCollisionsOfGameObjects(bool& quit, GameTime* gameTime) {
+void GameObjectManager::handleCollisionsOfGameObjects(GameState* gameState) {
 	collisionResolver.handlePlayerCollision();
-	collisionResolver.handleBarrelsCollision(&quit, gameTime);
+	collisionResolver.handleBarrelsCollision(gameState);
 }
 
 void GameObjectManager::updateSpritesOfGameObjects() {

libs/GameObjectManager.h

@@ -7,6 +7,7 @@
 #include "PhysicsManager.h"
 #include "AnimationManager.h"
 #include "GameTime.h"
+#include "GameState.h"
 
 class GameObjectManager {
 public:
@@ -20,7 +21,7 @@ class GameObjectManager {
 	explicit GameObjectManager(std::shared_ptr<GameObjectContainer> gameObjectContainer);
 
 	void updatePositionOfGameObjects(double deltaTime);
-	void handleCollisionsOfGameObjects(bool& openGameOverMenu, GameTime* gameTime);
+	void handleCollisionsOfGameObjects(GameState* gameState);
 	void updateSpritesOfGameObjects();
 	void updatePhysicsOfGameObjects(double deltaTime);
 };

libs/KeyActionHandler.cpp

@@ -1,11 +1,13 @@
 #include "KeyActionHandler.h"
 
-KeyActionHandler::KeyActionHandler(std::set<SDL_Keycode>* pressedKeys, std::set<SDL_Keycode>* releasedKeys, GameTime* gameTime, GameObjectContainer* gameObjectContainer, Menu* pauseMenu, GameState* gameState)
+KeyActionHandler::KeyActionHandler(std::set<SDL_Keycode>* pressedKeys, std::set<SDL_Keycode>* releasedKeys, GameTime* gameTime, GameObjectContainer* gameObjectContainer, Menu* pauseMenu, Menu* gameOverMenu, Menu* startingScreenMenu, GameState* gameState)
 	: pressedKeys(pressedKeys)
 	, releasedKeys(releasedKeys)
 	, gameTime(gameTime)
 	, gameObjectContainer(gameObjectContainer)
 	, pauseMenu(pauseMenu)
+	, gameOverMenu(gameOverMenu)
+	, startingScreenMenu(startingScreenMenu)
 	, gameState(gameState)
 {
 }
@@ -93,8 +95,19 @@ void KeyActionHandler::handleReleasedKeys() {
 	}
 }
 
-// PROBLEMEM JEST TO ŻE KAŻDA Z TYCH FUNCKJI JEST WYKONYWANA RAZ TYLKO JAK WCISNIESZ I PRZERYWANA JAK PUSCICSZ
-// CZYLI TYLKO RAZ NA POCZATKU SPRZAWDZI CZY JEST WEWNATRZ DRABINY
+Menu* KeyActionHandler::getCurrentActiveMenu() {
+	switch (*gameState) {
+	case GameState::PAUSE:
+		return pauseMenu;
+	case GameState::GAME_OVER:
+		return gameOverMenu;
+	case GameState::START:
+		return startingScreenMenu;
+	default:
+		return nullptr;
+	}
+}
+
 void KeyActionHandler::onKeyPressArrowUp() {
 	if (*gameState == GameState::RUNNING) {
 		auto player = gameObjectContainer->player;
@@ -106,8 +119,9 @@ void KeyActionHandler::onKeyPressArrowUp() {
 			player->velocityY = DEFAULT_PLAYER_SPEED;
 		}
 	}
-	else if (*gameState == GameState::PAUSE) {
-		pauseMenu->selectPreviousOption();
+	else {
+		Menu* currentMenu = getCurrentActiveMenu();
+		currentMenu->selectPreviousOption();
 	}
 }
 
@@ -122,8 +136,9 @@ void KeyActionHandler::onKeyPressArrowDown() {
 			player->velocityY = DEFAULT_PLAYER_SPEED;
 		}
 	}
-	else if (*gameState == GameState::PAUSE) {
-		pauseMenu->selectNextOption();
+	else {
+		Menu* currentMenu = getCurrentActiveMenu();
+		currentMenu->selectNextOption();
 	}
 }
 
@@ -155,7 +170,13 @@ void KeyActionHandler::onKeyPressSpace() {
 
 void KeyActionHandler::onKeyPressEnter() {
 	if (*gameState == GameState::PAUSE) {
-		handleMenuSelection();
+		handlePauseMenuSelection();
+	}
+	else if (*gameState == GameState::GAME_OVER) {
+		handleGameOverMenuSelection();
+	}
+	else if (*gameState == GameState::START) {
+		handleStartingScreenMenuSelection();
 	}
 }
 
@@ -168,34 +189,46 @@ void KeyActionHandler::onKeyPressEsc() {
 	}
 }
 
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-// so this function gets executed only the second time you press esc
-//void KeyActionHandler::onKeyPressEsc() {
-//	if (!gameTime->isPaused) {
-//		moveAllHandledKeysToReleasedKeys();
-//		handleReleasedKeys();
-//		gameTime->pause();
-//	}
-//	else {
-//		moveAllHandledKeysToReleasedKeys();
-//		handleReleasedKeys();
-//		gameTime->resume();
-//	}
-//}
-
-void KeyActionHandler::handleMenuSelection() {
+// "Resume", "Leaderboard", "Quit"
+void KeyActionHandler::handlePauseMenuSelection() {
 	switch (pauseMenu->selectedOptionIndex) {
 		case 0: // Resume
-			moveAllHandledKeysToReleasedKeys();
-			handleReleasedKeys();
-			gameTime->resume();
+			*gameState = GameState::RUNNING;
 			break;
 		case 1: // Leaderboard
 			break;
 		case 2: // Quit
-			SDL_Event quitEvent;
-			quitEvent.type = SDL_QUIT;
-			SDL_PushEvent(&quitEvent);
+			*gameState = GameState::QUIT;
+			break;
+	}
+}
+
+// "Retry", "Quit"
+void KeyActionHandler::handleGameOverMenuSelection() {
+	switch (gameOverMenu->selectedOptionIndex) {
+		case 0: // Restart
+			// *gameState = GameState::RESTART;
+			break;
+		case 1: // Quit
+			*gameState = GameState::QUIT;
+			break;
+	}
+}
+
+// "New Game", "Load Game", "Leaderboard", "Options", "Quit"
+void KeyActionHandler::handleStartingScreenMenuSelection() {
+	switch (startingScreenMenu->selectedOptionIndex) {
+		case 0: // Start
+			*gameState = GameState::RUNNING;
+			break;
+		case 1: // Load Game
+			break;
+		case 2: // Leaderboard
+			break;
+		case 3: // Options
+			break;
+		case 4: // Quit
+			*gameState = GameState::QUIT;
 			break;
 	}
 }

libs/KeyActionHandler.h

@@ -18,10 +18,14 @@ class KeyActionHandler {
 
 	std::shared_ptr<GameTime> gameTime;
 	std::shared_ptr<GameObjectContainer> gameObjectContainer;
-	std::shared_ptr<Menu> pauseMenu;
+
+	Menu* pauseMenu;
+	Menu* gameOverMenu;
+	Menu* startingScreenMenu;
+
 	GameState* gameState;
 
-	KeyActionHandler(std::set<SDL_Keycode>* pressedKeys, std::set<SDL_Keycode>* releasedKeys, GameTime* gameTime, GameObjectContainer* gameObjectContainer, Menu* pauseMenu, GameState* gameState);
+	KeyActionHandler(std::set<SDL_Keycode>* pressedKeys, std::set<SDL_Keycode>* releasedKeys, GameTime* gameTime, GameObjectContainer* gameObjectContainer, Menu* pauseMenu, Menu* gameOverMenu, Menu* startingScreenMenu, GameState* gameState);
 
 	void handleInput();
 	void handlePressedKeys();
@@ -47,5 +51,8 @@ class KeyActionHandler {
 	void moveAllPressedKeysToReleasedKeys();
 	void moveAllHandledKeysToReleasedKeys();
 
-	void handleMenuSelection();
+	Menu* getCurrentActiveMenu();
+	void handlePauseMenuSelection();
+	void handleGameOverMenuSelection();
+	void handleStartingScreenMenuSelection();
 };