diff --git a/Array-Jumper/Array-Jumper.vcxproj b/Array-Jumper/Array-Jumper.vcxproj index 658ea835..2822c6ae 100644 --- a/Array-Jumper/Array-Jumper.vcxproj +++ b/Array-Jumper/Array-Jumper.vcxproj @@ -1,4 +1,4 @@ - + @@ -133,14 +133,26 @@ + + + + + + + + + + + + @@ -152,12 +164,28 @@ + + + + + + + + + + + + + + + + diff --git a/Array-Jumper/Array-Jumper.vcxproj.filters b/Array-Jumper/Array-Jumper.vcxproj.filters index dff4a580..b0fe95f1 100644 --- a/Array-Jumper/Array-Jumper.vcxproj.filters +++ b/Array-Jumper/Array-Jumper.vcxproj.filters @@ -44,6 +44,17 @@ + + + + + + + + + + + @@ -74,6 +85,20 @@ + + + + + + + + + + + + + + diff --git a/Array-Jumper/header/GamePlay/GamePlayController.h b/Array-Jumper/header/GamePlay/GamePlayController.h new file mode 100644 index 00000000..7ba423ea --- /dev/null +++ b/Array-Jumper/header/GamePlay/GamePlayController.h @@ -0,0 +1,31 @@ +#pragma once +#include "../../header/Level/BlockType.h" + +namespace GamePlay +{ + + class GamePlayController + { + public: + GamePlayController(); + ~GamePlayController(); + + void initialize(); + void update(); + void render(); + void onDeath(); + void gameWon(); + void loadNextLevel(); + bool isLastLevel(); + + private: + void processObstacle(); + bool isCollidingWithObstacle(BlockType value); + void onPositionChanged(int position); + bool isEndBlock(BlockType value); + void processEndBlock(); + void gameOver(); + }; + + +} \ No newline at end of file diff --git a/Array-Jumper/header/GamePlay/GamePlayService.h b/Array-Jumper/header/GamePlay/GamePlayService.h new file mode 100644 index 00000000..f994bd36 --- /dev/null +++ b/Array-Jumper/header/GamePlay/GamePlayService.h @@ -0,0 +1,25 @@ +#pragma once +namespace GamePlay +{ + class GamePlayController; + class GamePlayService + { + public: + GamePlayService(); + ~GamePlayService(); + + + void initialize(); + void update(); + void render(); + + void onDeath(); + + + private: + GamePlayController* m_gamePlayController; + }; + + + +} \ No newline at end of file diff --git a/Array-Jumper/header/Global/ServiceLocator.h b/Array-Jumper/header/Global/ServiceLocator.h index 7e9ef35a..bc76eeae 100644 --- a/Array-Jumper/header/Global/ServiceLocator.h +++ b/Array-Jumper/header/Global/ServiceLocator.h @@ -3,6 +3,9 @@ #include "../../header/Event/EventService.h" #include "../../header/UI/UIService.h" #include "../../header/Sound/SoundService.h" +#include "../../header/Player/PlayerService.h" +#include "../../header/Level/LevelService.h" +#include "../../header/GamePlay/GamePlayService.h" namespace Global { @@ -13,6 +16,9 @@ namespace Global Event::EventService* event_service; Sound::SoundService* sound_service; UI::UIService* ui_service; + Player::PlayerService* player_service; + Level::LevelService* level_service; + GamePlay::GamePlayService* game_play_service; ~ServiceLocator(); @@ -31,5 +37,8 @@ namespace Global Event::EventService* getEventService(); Sound::SoundService* getSoundService(); UI::UIService* getUIService(); + Player::PlayerService* getPlayerService(); + Level::LevelService* getLevelService(); + GamePlay::GamePlayService* getGamePlayService(); }; } \ No newline at end of file diff --git a/Array-Jumper/header/Level/BlockType.h b/Array-Jumper/header/Level/BlockType.h new file mode 100644 index 00000000..8f7e9db6 --- /dev/null +++ b/Array-Jumper/header/Level/BlockType.h @@ -0,0 +1,11 @@ +#pragma once + +enum class BlockType +{ + OBSTACLE_ONE = -1, + OBSTACLE_TWO = -2, + TARGET = 0, + ONE = 1, + TWO = 2, + THREE = 3, +}; \ No newline at end of file diff --git a/Array-Jumper/header/Level/LevelConfiguration.h b/Array-Jumper/header/Level/LevelConfiguration.h new file mode 100644 index 00000000..8e111a92 --- /dev/null +++ b/Array-Jumper/header/Level/LevelConfiguration.h @@ -0,0 +1,45 @@ +#pragma once +#include "../../header/Level/BlockType.h" +#include "../../header/Level/LevelData.h" + +namespace Level +{ + class LevelConfiguration + { + public: + static const int number_of_levels = 3; + LevelData levels[number_of_levels]; + LevelConfiguration() { + + for (int i = 0; i < LevelData::number_of_box; i++) + { + levels[0].level_boxes[i] = level_1[i]; + } + + for (int i = 0; i < LevelData::number_of_box; i++) + { + levels[1].level_boxes[i] = level_2[i]; + } + for (int i = 0; i < LevelData::number_of_box; i++) + { + levels[2].level_boxes[i] = level_3[i]; + } + }; + + private: + BlockType level_1[LevelData::number_of_box] = + { + BlockType::ONE, BlockType::TWO, BlockType::OBSTACLE_ONE, BlockType::TWO, BlockType::THREE, BlockType::ONE, BlockType::OBSTACLE_TWO, BlockType::TWO, BlockType::ONE, BlockType::TARGET + }; + + BlockType level_2[LevelData::number_of_box] = + { + BlockType::ONE, BlockType::TWO, BlockType::OBSTACLE_TWO, BlockType::ONE, BlockType::TWO, BlockType::OBSTACLE_ONE, BlockType::THREE, BlockType::OBSTACLE_ONE, BlockType::ONE, BlockType::TARGET + }; + + BlockType level_3[LevelData::number_of_box] = + { + BlockType::ONE, BlockType::THREE, BlockType::OBSTACLE_ONE, BlockType::OBSTACLE_TWO, BlockType::ONE, BlockType::TWO, BlockType::OBSTACLE_ONE, BlockType::TWO, BlockType::ONE, BlockType::TARGET + }; + }; +} diff --git a/Array-Jumper/header/Level/LevelController.h b/Array-Jumper/header/Level/LevelController.h new file mode 100644 index 00000000..103f6043 --- /dev/null +++ b/Array-Jumper/header/Level/LevelController.h @@ -0,0 +1,29 @@ +#pragma once +#include "BlockType.h" +#include "../../header/Level/LevelModel.h" +namespace Level +{ + class LevelModel; + class LevelView; + class LevelController + { + public: + LevelController(); + ~LevelController(); + + void initialize(); + void update(); + void render(); + + BlockType getCurrentBoxValue(int currenPosition); + BoxDimension getBoxDimension(); + bool isLastLevel(); + void nextLevel(); + int getCurrentLevelIndex(); + void reset(); + + private: + LevelModel* level_model; + LevelView* level_view; + }; +} \ No newline at end of file diff --git a/Array-Jumper/header/Level/LevelData.h b/Array-Jumper/header/Level/LevelData.h new file mode 100644 index 00000000..e39c4ada --- /dev/null +++ b/Array-Jumper/header/Level/LevelData.h @@ -0,0 +1,15 @@ +#pragma once +#include "../../header/Level/BlockType.h" + +namespace Level +{ + struct LevelData + { + static const int number_of_box = 10; + BlockType level_boxes[number_of_box]; + + + + }; +} + diff --git a/Array-Jumper/header/Level/LevelModel.h b/Array-Jumper/header/Level/LevelModel.h new file mode 100644 index 00000000..f5d5a0bd --- /dev/null +++ b/Array-Jumper/header/Level/LevelModel.h @@ -0,0 +1,35 @@ +#pragma once +#include "../../header/Level/LevelData.h" +#include "../../header/Level/LevelConfiguration.h" +namespace Level +{ + struct BoxDimension + { + float box_width; + float box_height; + + float box_spacing; + + float box_spacing_percentage = 0.3f; + float bottom_offset = 200.f; + + }; + class LevelModel + { + public: + LevelModel(); + ~LevelModel(); + + BlockType getCurrentBoxValue(int currentPosition); + void nextLevel(); + int getCurrentLevelIndex(); + bool isLastLevel(); + void reset(); + + private: + int current_level_index = 0; + LevelConfiguration level_configuration; + }; + + +} \ No newline at end of file diff --git a/Array-Jumper/header/Level/LevelService.h b/Array-Jumper/header/Level/LevelService.h new file mode 100644 index 00000000..47602b02 --- /dev/null +++ b/Array-Jumper/header/Level/LevelService.h @@ -0,0 +1,29 @@ +#pragma once +#include "BlockType.h" +namespace Level +{ + struct BoxDimension; + class LevelController; + class BoxType; + class LevelService + { + public: + LevelService(); + ~LevelService(); + + void initialize(); + void update(); + void render(); + + BoxDimension getBoxDimension(); + BlockType getCurrentBoxValue(int currentPosition); + bool isLastLevel(); + void nextLevel(); + int getCurrentLevelIndex(); + void reset(); + + private: + LevelController* level_controller; + }; + +} \ No newline at end of file diff --git a/Array-Jumper/header/Level/LevelView.h b/Array-Jumper/header/Level/LevelView.h new file mode 100644 index 00000000..d2149b2f --- /dev/null +++ b/Array-Jumper/header/Level/LevelView.h @@ -0,0 +1,54 @@ +#pragma once +#include "../../header/UI/UIElement/ImageView.h" +#include "LevelModel.h" +namespace Level +{ + class LevelController; + class LevelView + { + public: + LevelView(LevelController* controller); + ~LevelView(); + + void initilaize(); + void update(); + void render(); + + void calculateBoxWidthHeightDimension(); + void calculateBoxSpacing(); + void calcuateBoxDimension(); + sf::Vector2f calculateBoxPosition(int index); + UI::UIElement::ImageView* getBoxImage(BlockType type); + + void drawBox(sf::Vector2f position); + void drawBoxValue(sf::Vector2f position, BlockType type); + + BoxDimension getBoxDimension(); + + + + private: + LevelController* level_controller; + UI::UIElement::ImageView* background_image; + UI::UIElement::ImageView* box_image; + sf::RenderWindow* game_window; + + const float background_alpha = 110.f; + + BoxDimension box_dimension; + + UI::UIElement::ImageView* target_overlay_image; + UI::UIElement::ImageView* letter_one_overlay_image; + UI::UIElement::ImageView* letter_two_overlay_image; + UI::UIElement::ImageView* letter_three_overlay_image; + UI::UIElement::ImageView* obstacle_one_overlay_image; + UI::UIElement::ImageView* obstacle_two_overlay_image; + + void createImage(); + void initilizeImage(); + void updateImage(); + void drawImage(); + void deleteImage(); + }; + +} \ No newline at end of file diff --git a/Array-Jumper/header/Main/GameService.h b/Array-Jumper/header/Main/GameService.h index fdeef9e7..7a2a1a77 100644 --- a/Array-Jumper/header/Main/GameService.h +++ b/Array-Jumper/header/Main/GameService.h @@ -16,6 +16,7 @@ namespace Main GAMEPLAY, INSTRUCTIONS, CREDITS, + GAMEOVER }; class GameService diff --git a/Array-Jumper/header/Player/Movement.h b/Array-Jumper/header/Player/Movement.h new file mode 100644 index 00000000..4c7239ca --- /dev/null +++ b/Array-Jumper/header/Player/Movement.h @@ -0,0 +1,9 @@ +#pragma once +namespace Player +{ + enum class MovementDirection + { + FORWARD, + BACKWARD + }; +} diff --git a/Array-Jumper/header/Player/PlayerController.h b/Array-Jumper/header/Player/PlayerController.h new file mode 100644 index 00000000..8610ddf7 --- /dev/null +++ b/Array-Jumper/header/Player/PlayerController.h @@ -0,0 +1,44 @@ +#pragma once +#include "../../header/Event/EventService.h" +namespace Player +{ + class PlayerModel; + class PlayerView; + class EventService; + enum class PlayerState; + enum class MovementDirection; + + class PlayerController + { + public: + PlayerController(); + ~ PlayerController(); + + void initialize(); + void update(); + void render(); + + PlayerState getPlayerState(); + void setPlayerState(PlayerState state); + + + void movePlayer(MovementDirection direction); + void jump(MovementDirection direction); + bool isPositionValid(int targetPosition); + + void readInput(); + + int getCurrentPosition(); + void takeDamage(); + void levelComplete(); + + int getCurrentLives(); + void onDeath(); + private: + PlayerModel* player_model; + PlayerView* player_view; + Event::EventService* event_service; + + + }; +} \ No newline at end of file diff --git a/Array-Jumper/header/Player/PlayerModel.h b/Array-Jumper/header/Player/PlayerModel.h new file mode 100644 index 00000000..86c69152 --- /dev/null +++ b/Array-Jumper/header/Player/PlayerModel.h @@ -0,0 +1,36 @@ +#pragma once +namespace Player +{ + enum class PlayerState + { + ALIVE, + DEAD + }; + + class PlayerModel + { + public: + + void initialize(); + void update(); + + int current_lives; + int getPosition(); + void setPosition(int player_position); + + PlayerState getPlayerState(); + void setPlayerState(PlayerState state); + void resetPlayer(); + + int getCurrentLives(); + void decrementLife(); + void resetPositon(); + private: + int current_position; + const int max_lives = 3; + PlayerState player_state; + + }; + + +} \ No newline at end of file diff --git a/Array-Jumper/header/Player/PlayerService.h b/Array-Jumper/header/Player/PlayerService.h new file mode 100644 index 00000000..ec9a18cd --- /dev/null +++ b/Array-Jumper/header/Player/PlayerService.h @@ -0,0 +1,27 @@ +#pragma once +namespace Player +{ + class PlayerController; + class PlayerService + { + public: + PlayerService(); + ~PlayerService(); + + void initialize(); + void update(); + void render(); + + void takeDamage(); + int getCurrentPosition(); + void levelComplete(); + + int getCurrentLives(); + void onDeath(); + + private: + PlayerController* player_conroller; + }; + + +} \ No newline at end of file diff --git a/Array-Jumper/header/Player/PlayerView.h b/Array-Jumper/header/Player/PlayerView.h new file mode 100644 index 00000000..ba9077a3 --- /dev/null +++ b/Array-Jumper/header/Player/PlayerView.h @@ -0,0 +1,39 @@ +#pragma once +#include "../../header/UI/UIElement/ImageView.h" +#include "../../header/Level/LevelModel.h" + +namespace Player +{ + using namespace Level; + class PlayerController; + class PlayerView + { + public: + PlayerView(PlayerController* controller); + ~PlayerView(); + + void initialize(); + void update(); + void render(); + + BoxDimension current_box_dimensions; + + private: + UI::UIElement::ImageView* player_image; + sf::RenderWindow* game_window; + + PlayerController* player_controller; + + float player_height; + float player_width; + + void initializePlayerImage(); + void drawPlayer(); + void loadImage(); + void calculatePlayerDimension(); + void updatePlayerPosition(); + + sf::Vector2f calculatePlayerPosition(); + + }; +} \ No newline at end of file diff --git a/Array-Jumper/header/UI/Credits/CreditsScreenUIController.h b/Array-Jumper/header/UI/Credits/CreditsScreenUIController.h index d2ba2856..b13237b8 100644 --- a/Array-Jumper/header/UI/Credits/CreditsScreenUIController.h +++ b/Array-Jumper/header/UI/Credits/CreditsScreenUIController.h @@ -15,6 +15,7 @@ namespace UI // Constants: const sf::String game_title = "Outscal Presents - Array Jumper"; + const sf::String won_text = "Game Won"; const float background_alpha = 85.f; const float text_top_offset = 260.f; @@ -31,6 +32,7 @@ namespace UI UIElement::TextView* title_text; UIElement::ButtonView* menu_button; UIElement::ButtonView* quit_button; + UIElement::TextView* won_textView; void createText(); void createImage(); diff --git a/Array-Jumper/header/UI/GameOver/GameOverController.h b/Array-Jumper/header/UI/GameOver/GameOverController.h new file mode 100644 index 00000000..47fb370b --- /dev/null +++ b/Array-Jumper/header/UI/GameOver/GameOverController.h @@ -0,0 +1,63 @@ +#pragma once +#include +#include "../../header/UI/UIElement/ImageView.h" +#include "../../header/UI/UIElement/ButtonView.h" +#include "../../header/UI/UIElement/TextView.h" + +namespace UI +{ + namespace GameOverUI + { + class GameOverController + { + private: + + // Constants: + const sf::String game_title = "Outscal Presents - Array Jumper"; + const sf::String game_over_text = "Game Over"; + const float background_alpha = 85.f; + + const float text_top_offset = 260.f; + const int font_size = 110; + const sf::Color text_color = sf::Color::White; + + const float button_width = 400.f; + const float button_height = 140.f; + const float menu_button_y_position = 600.f; + const float quit_button_y_position = 800.f; + + // UI Elements: + UI::UIElement::ImageView* background_image; + UI::UIElement::TextView* title_text; + UI::UIElement::TextView* gameover_text; + UI::UIElement::ButtonView* menu_button; + UI::UIElement::ButtonView* quit_button; + + void createText(); + void createImage(); + void createButtons(); + + void initializeText(); + void initializeBackgroundImage(); + void initializeButtons(); + + void registerButtonCallback(); + + void menuButtonCallback(); + void quitButtonCallback(); + + void destroy(); + + public: + GameOverController(); + ~GameOverController(); + + void initialize(); + void update(); + void render(); + void show(); + }; + + + } +} diff --git a/Array-Jumper/header/UI/GamePlay/GameplayUIController.h b/Array-Jumper/header/UI/GamePlay/GameplayUIController.h new file mode 100644 index 00000000..0f1145a7 --- /dev/null +++ b/Array-Jumper/header/UI/GamePlay/GameplayUIController.h @@ -0,0 +1,31 @@ +#pragma once +#include "../../header/UI/UIElement/TextView.h" +namespace GamePlayUI +{ + class GameplayUIController + { + public: + GameplayUIController(); + ~ GameplayUIController(); + + void initialize(); + void update(); + void render(); + + private: + float font_size = 55; + + const float top_offset = 100.f; + const float left_offset = 150.f; + const float right_offset = 250.f; + + UI::UIElement::TextView* m_liveTextView; + UI::UIElement::TextView* m_levelTextView; + void createTextView(); + void initializeTextView(); + void updateTextView(); + + }; + + +} \ No newline at end of file diff --git a/Array-Jumper/header/UI/UIService.h b/Array-Jumper/header/UI/UIService.h index 8db7e889..814dd353 100644 --- a/Array-Jumper/header/UI/UIService.h +++ b/Array-Jumper/header/UI/UIService.h @@ -5,9 +5,12 @@ #include "../../header/UI/MainMenu/MainMenuUIController.h" #include "../../header/UI/Instructions/InstructionsUIController.h" #include "../../header/UI/Credits/CreditsScreenUIController.h" +#include "../../header/UI/GamePlay/GameplayUIController.h" +#include "../../header/UI/GameOver/GameOverController.h" namespace UI { + class UIService { @@ -16,6 +19,8 @@ namespace UI MainMenu::MainMenuUIController* main_menu_ui_controller; Credits::CreditsScreenUIController* credits_screen_ui_controller; Instructions::InstructionsUIController* instructions_ui_controller; + GamePlayUI::GameplayUIController* gameplay_ui_controller; + GameOverUI::GameOverController* gameover_ui_controller; void createControllers(); diff --git a/Array-Jumper/source/GamePlay/GamePlayController.cpp b/Array-Jumper/source/GamePlay/GamePlayController.cpp new file mode 100644 index 00000000..55f80a83 --- /dev/null +++ b/Array-Jumper/source/GamePlay/GamePlayController.cpp @@ -0,0 +1,109 @@ +#include "../../header/GamePlay/GamePlayController.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Sound/SoundService.h" +#include "../../header/Level/LevelService.h" +#include "../../header/Main/GameService.h" + +using namespace Global; +using namespace Sound; +using namespace Level; +using namespace Main; + + +GamePlay::GamePlayController::GamePlayController() +{ +} + +GamePlay::GamePlayController::~GamePlayController() +{ +} + +void GamePlay::GamePlayController::initialize() +{ +} + +void GamePlay::GamePlayController::update() +{ + onPositionChanged(ServiceLocator::getInstance()->getPlayerService()->getCurrentPosition()); +} + +void GamePlay::GamePlayController::render() +{ +} + +void GamePlay::GamePlayController::processObstacle() +{ + ServiceLocator::getInstance()->getPlayerService()->takeDamage(); + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::DEATH); +} + +bool GamePlay::GamePlayController::isCollidingWithObstacle(BlockType value) +{ + if (value == BlockType::OBSTACLE_ONE || value == BlockType::OBSTACLE_TWO) + { + return true; + } + return false; +} + +void GamePlay::GamePlayController::onPositionChanged(int position) +{ + BlockType block = ServiceLocator::getInstance()->getLevelService()->getCurrentBoxValue(position); + if (isCollidingWithObstacle(block)) + { + processObstacle(); + } + if (isEndBlock(block)) + { + processEndBlock(); + } +} + +bool GamePlay::GamePlayController::isEndBlock(BlockType value) +{ + if (value == BlockType::TARGET) + { + return true; + } + return false; +} + +void GamePlay::GamePlayController::processEndBlock() +{ + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::LEVEL_COMPLETE); + ServiceLocator::getInstance()->getPlayerService()->levelComplete(); + + if (isLastLevel()) + { + gameWon(); + return; + } + loadNextLevel(); +} + +void GamePlay::GamePlayController::gameOver() +{ + GameService::setGameState(GameState::GAMEOVER); + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::DEATH); +} + +void GamePlay::GamePlayController::onDeath() +{ + gameOver(); +} + +void GamePlay::GamePlayController::gameWon() +{ + GameService::setGameState(GameState::CREDITS); + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::LEVEL_COMPLETE); +} + +void GamePlay::GamePlayController::loadNextLevel() +{ + ServiceLocator::getInstance()->getLevelService()->nextLevel(); +} + +bool GamePlay::GamePlayController::isLastLevel() +{ + return ServiceLocator::getInstance()->getLevelService()->isLastLevel(); +} diff --git a/Array-Jumper/source/GamePlay/GamePlayService.cpp b/Array-Jumper/source/GamePlay/GamePlayService.cpp new file mode 100644 index 00000000..182343df --- /dev/null +++ b/Array-Jumper/source/GamePlay/GamePlayService.cpp @@ -0,0 +1,33 @@ +#include "../../header/GamePlay/GamePlayService.h" +#include "../../header/GamePlay/GamePlayController.h" +#include "../../header/Global/ServiceLocator.h" +namespace GamePlay +{ + using namespace Global; + GamePlay::GamePlayService::GamePlayService() + { + m_gamePlayController = new GamePlayController(); + } + GamePlayService::~GamePlayService() + { + delete m_gamePlayController; + } + void GamePlayService::initialize() + { + m_gamePlayController->initialize(); + } + void GamePlayService::update() + { + m_gamePlayController->update(); + } + void GamePlayService::render() + { + m_gamePlayController->render(); + } + + void GamePlayService::onDeath() + { + m_gamePlayController->onDeath(); + } + +} \ No newline at end of file diff --git a/Array-Jumper/source/Global/ServiceLocator.cpp b/Array-Jumper/source/Global/ServiceLocator.cpp index 5aa28494..23454332 100644 --- a/Array-Jumper/source/Global/ServiceLocator.cpp +++ b/Array-Jumper/source/Global/ServiceLocator.cpp @@ -9,6 +9,9 @@ namespace Global using namespace Sound; using namespace UI; using namespace Main; + using namespace Player; + using namespace Level; + using namespace GamePlay; ServiceLocator::ServiceLocator() { @@ -16,6 +19,9 @@ namespace Global event_service = nullptr; sound_service = nullptr; ui_service = nullptr; + level_service = nullptr; + player_service = nullptr; + game_play_service = nullptr; createServices(); } @@ -28,6 +34,9 @@ namespace Global event_service = new EventService(); sound_service = new SoundService(); ui_service = new UIService(); + level_service = new LevelService(); + player_service = new PlayerService(); + game_play_service = new GamePlayService(); } void ServiceLocator::initialize() @@ -36,6 +45,9 @@ namespace Global event_service->initialize(); sound_service->initialize(); ui_service->initialize(); + level_service->initialize(); + player_service->initialize(); + game_play_service->initialize(); } void ServiceLocator::update() @@ -43,12 +55,26 @@ namespace Global graphic_service->update(); event_service->update(); ui_service->update(); + if (GameService::getGameState() == GameState::GAMEPLAY) + { + level_service->update(); + player_service->update(); + game_play_service->update(); + + } } void ServiceLocator::render() { graphic_service->render(); ui_service->render(); + if (GameService::getGameState() == GameState::GAMEPLAY) + { + level_service->render(); + player_service->render(); + game_play_service->render(); + + } } void ServiceLocator::clearAllServices() @@ -57,6 +83,9 @@ namespace Global delete(event_service); delete(sound_service); delete(ui_service); + delete(level_service); + delete(player_service); + delete(game_play_service); } ServiceLocator* ServiceLocator::getInstance() @@ -72,4 +101,17 @@ namespace Global SoundService* ServiceLocator::getSoundService() { return sound_service; } UIService* ServiceLocator::getUIService() { return ui_service; } + Level::LevelService* ServiceLocator::getLevelService() + { + return level_service; + } + GamePlay::GamePlayService* ServiceLocator::getGamePlayService() + { + return game_play_service; + } + Player::PlayerService* ServiceLocator::getPlayerService() + { + return player_service; + } + } \ No newline at end of file diff --git a/Array-Jumper/source/Level/LevelController.cpp b/Array-Jumper/source/Level/LevelController.cpp new file mode 100644 index 00000000..81826147 --- /dev/null +++ b/Array-Jumper/source/Level/LevelController.cpp @@ -0,0 +1,53 @@ +#include "../../header/Level/LevelController.h" +#include "../../header/Level/LevelView.h" +namespace Level +{ + Level::LevelController::LevelController() + { + level_model = new LevelModel(); + level_view = new LevelView(this); + } + LevelController::~LevelController() + { + delete(level_model); + delete(level_view); + + } + void LevelController::initialize() + { + level_view->initilaize(); + } + void LevelController::update() + { + level_view->update(); + } + void LevelController::render() + { + level_view->render(); + } + BlockType LevelController::getCurrentBoxValue(int currentPosition) + { + return level_model->getCurrentBoxValue(currentPosition); + } + BoxDimension LevelController::getBoxDimension() + { + return level_view->getBoxDimension(); + } + bool LevelController::isLastLevel() + { + return level_model->isLastLevel(); + } + void LevelController::nextLevel() + { + level_model->nextLevel(); + } + int LevelController::getCurrentLevelIndex() + { + return level_model->getCurrentLevelIndex(); + } + + void LevelController::reset() + { + level_model->reset(); + } +} \ No newline at end of file diff --git a/Array-Jumper/source/Level/LevelModel.cpp b/Array-Jumper/source/Level/LevelModel.cpp new file mode 100644 index 00000000..a3c99ebc --- /dev/null +++ b/Array-Jumper/source/Level/LevelModel.cpp @@ -0,0 +1,37 @@ +#include "../../header/Level/LevelModel.h" +#include + +namespace Level +{ + Level::LevelModel::LevelModel() + { + } + LevelModel::~LevelModel() + { + } + BlockType LevelModel::getCurrentBoxValue(int currentPosition) + { + std::cout << currentPosition << std::endl; + return level_configuration.levels[current_level_index].level_boxes[currentPosition]; + } + void LevelModel::nextLevel() + { + current_level_index++; + } + int LevelModel::getCurrentLevelIndex() + { + return current_level_index + 1; + } + bool LevelModel::isLastLevel() + { + if (current_level_index == LevelConfiguration::number_of_levels - 1) + { + return true; + } + return false; + } + void LevelModel::reset() + { + current_level_index = 0; + } +} \ No newline at end of file diff --git a/Array-Jumper/source/Level/LevelService.cpp b/Array-Jumper/source/Level/LevelService.cpp new file mode 100644 index 00000000..461ff082 --- /dev/null +++ b/Array-Jumper/source/Level/LevelService.cpp @@ -0,0 +1,50 @@ +#include "../../header/Level/LevelService.h" +#include "../../header/Level/LevelController.h" +#include "../../header/Level/LevelModel.h" +namespace Level +{ + Level::LevelService::LevelService() + { + level_controller = new LevelController(); + } + LevelService::~LevelService() + { + delete(level_controller); + } + void LevelService::initialize() + { + level_controller->initialize(); + } + void LevelService::update() + { + level_controller->update(); + } + void LevelService::render() + { + level_controller->render(); + } + BoxDimension LevelService::getBoxDimension() + { + return level_controller->getBoxDimension(); + } + BlockType LevelService::getCurrentBoxValue(int currentPosition) + { + return level_controller->getCurrentBoxValue(currentPosition); + } + bool LevelService::isLastLevel() + { + return level_controller->isLastLevel(); + } + void LevelService::nextLevel() + { + level_controller->nextLevel(); + } + int LevelService::getCurrentLevelIndex() + { + return level_controller->getCurrentLevelIndex(); + } + void LevelService::reset() + { + level_controller->reset(); + } +} \ No newline at end of file diff --git a/Array-Jumper/source/Level/LevelView.cpp b/Array-Jumper/source/Level/LevelView.cpp new file mode 100644 index 00000000..f7f7e290 --- /dev/null +++ b/Array-Jumper/source/Level/LevelView.cpp @@ -0,0 +1,169 @@ +#include "../../header/Level/LevelView.h" +#include "../../header/Level/LevelController.h" +#include "../../header/Global/Config.h" +#include "../../header/Global/ServiceLocator.h" +#include +namespace Level +{ + using namespace Global; + using namespace UI::UIElement; + + Level::LevelView::LevelView(LevelController* controller) + { + level_controller = controller; + game_window = nullptr; + createImage(); + } + LevelView::~LevelView() + { + deleteImage(); + } + void LevelView::initilaize() + { + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + calcuateBoxDimension(); + initilizeImage(); + } + void LevelView::update() + { + updateImage(); + } + void LevelView::render() + { + drawImage(); + } + void LevelView::calculateBoxWidthHeightDimension() + { + float screenWidth = static_cast(game_window->getSize().x); + int numBoxes = LevelData::number_of_box; + + //Each Box has a Gap on it's left, 1 extra gap for last block's right side + int numGaps = numBoxes + 1; + + //Total space consumed by all gaps + float totalSpaceByGaps = box_dimension.box_spacing_percentage * static_cast(numGaps); + + //Total space consumed by boxes and gaps + float totalSpace = numBoxes + totalSpaceByGaps; + + box_dimension.box_width = screenWidth / (totalSpace); + box_dimension.box_height = box_dimension.box_width; + } + void LevelView::calculateBoxSpacing() + { + box_dimension.box_spacing = box_dimension.box_spacing_percentage * box_dimension.box_width; + } + void LevelView::calcuateBoxDimension() + { + if (!game_window) return; + calculateBoxWidthHeightDimension(); + calculateBoxSpacing(); + } + sf::Vector2f LevelView::calculateBoxPosition(int index) + { + float xPosition = box_dimension.box_spacing + static_cast(index) * (box_dimension.box_width + box_dimension.box_spacing); + float yPosition = static_cast(game_window->getSize().y) - box_dimension.box_height - box_dimension.bottom_offset; + return sf::Vector2f(xPosition, yPosition); + } + ImageView* LevelView::getBoxImage(BlockType type) + { + switch (type) + { + case BlockType::OBSTACLE_ONE: + return obstacle_one_overlay_image; + break; + case BlockType::OBSTACLE_TWO: + return obstacle_two_overlay_image; + break; + case BlockType::TARGET: + return target_overlay_image; + break; + case BlockType::ONE: + return letter_one_overlay_image; + break; + case BlockType::TWO: + return letter_two_overlay_image; + break; + case BlockType::THREE: + return letter_three_overlay_image; + break; + } + } + void LevelView::drawBox(sf::Vector2f position) + { + box_image->setPosition(position); + box_image->render(); + } + void LevelView::drawBoxValue(sf::Vector2f position, BlockType type) + { + ImageView* image = getBoxImage(type); + image->setPosition(position); + image->render(); + } + BoxDimension LevelView::getBoxDimension() + { + return box_dimension; + } + void LevelView::createImage() + { + background_image = new ImageView(); + box_image = new ImageView(); + target_overlay_image = new ImageView(); + letter_one_overlay_image = new ImageView(); + letter_two_overlay_image = new ImageView(); + letter_three_overlay_image = new ImageView(); + obstacle_one_overlay_image = new ImageView(); + obstacle_two_overlay_image = new ImageView(); + + + } + void LevelView::initilizeImage() + { + + background_image->initialize(Config::array_jumper_bg_texture_path, game_window->getSize().x, game_window->getSize().y, sf::Vector2f(0, 0)); + background_image->setImageAlpha(background_alpha); + + box_image->initialize(Config::box_texture_path, box_dimension.box_width, box_dimension.box_height, sf::Vector2f(0, 0)); + //target_overlay_image->initialize(Config::target_texture_path, box_dimension.box_width, box_dimension.box_height, sf::Vector2f(0, 0)); + letter_one_overlay_image->initialize(Config::letter_one_texture_path, box_dimension.box_width, box_dimension.box_height, sf::Vector2f(0, 0)); + letter_two_overlay_image->initialize(Config::letter_two_texture_path, box_dimension.box_width, box_dimension.box_height, sf::Vector2f(0, 0)); + letter_three_overlay_image->initialize(Config::letter_three_texture_path, box_dimension.box_width, box_dimension.box_height, sf::Vector2f(0, 0)); + obstacle_one_overlay_image->initialize(Config::obstacle_01_texture_path, box_dimension.box_width, box_dimension.box_height, sf::Vector2f(0, 0)); + obstacle_two_overlay_image->initialize(Config::obstacle_02_texture_path, box_dimension.box_width, box_dimension.box_height, sf::Vector2f(0, 0)); + } + void LevelView::updateImage() + { + background_image->update(); + box_image->update(); + target_overlay_image->update(); + letter_one_overlay_image->update(); + letter_two_overlay_image->update(); + letter_three_overlay_image->update(); + obstacle_one_overlay_image->update(); + obstacle_two_overlay_image->update(); + } + void LevelView::drawImage() + { + background_image->render(); + + for (int i = 0; i < LevelData::number_of_box; i++) + { + sf::Vector2f positon = calculateBoxPosition(i); + BlockType blockTypeToDraw = level_controller->getCurrentBoxValue(i); + drawBox(positon); + drawBoxValue(positon, blockTypeToDraw); + } + + } + void LevelView::deleteImage() + { + delete(background_image); + delete(box_image); + delete(target_overlay_image); + delete(letter_one_overlay_image); + delete(letter_two_overlay_image); + delete(letter_three_overlay_image); + delete(obstacle_one_overlay_image); + delete(obstacle_two_overlay_image); + } +} \ No newline at end of file diff --git a/Array-Jumper/source/Player/PlayerController.cpp b/Array-Jumper/source/Player/PlayerController.cpp new file mode 100644 index 00000000..4e637e6e --- /dev/null +++ b/Array-Jumper/source/Player/PlayerController.cpp @@ -0,0 +1,183 @@ +#include "../../header/Player/PlayerController.h" +#include "../../header/Player/PlayerModel.h" +#include "../../header/Player/PlayerView.h" +#include "../../header/Player/Movement.h" +#include "../../header/Level/LevelData.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Global/Config.h" +#include "../../header/Sound/SoundService.h" +#include "../../header/Level/BlockType.h" +#include "../../header/GamePlay/GamePlayService.h" +#include + +namespace Player +{ + using namespace Level; + using namespace Global; + using namespace Sound; + Player::PlayerController::PlayerController() + { + player_model = new PlayerModel(); + player_view = new PlayerView(this); + } + Player::PlayerController::~PlayerController() + { + delete(player_model); + delete(player_view); + } + void PlayerController::initialize() + { + player_model->initialize(); + player_view->initialize(); + event_service = ServiceLocator::getInstance()->getEventService(); + + } + void PlayerController::update() + { + readInput(); + player_view->update(); + + } + void PlayerController::render() + { + player_view->render(); + } + PlayerState PlayerController::getPlayerState() + { + return player_model->getPlayerState(); + } + void PlayerController::setPlayerState(PlayerState state) + { + player_model->setPlayerState(state); + } + + int PlayerController::getCurrentPosition() + { + return player_model->getPosition(); + } + + void PlayerController::takeDamage() + { + player_model->decrementLife(); + + if (player_model->getCurrentLives() <= 0) + { + onDeath(); + } + else + { + player_model->resetPositon(); + + } + } + + void PlayerController::levelComplete() + { + player_model->resetPositon(); + } + + int PlayerController::getCurrentLives() + { + return player_model->getCurrentLives(); + } + + void PlayerController::onDeath() + { + ServiceLocator::getInstance()->getGamePlayService()->onDeath(); + player_model->resetPlayer(); + } + + void PlayerController::movePlayer(MovementDirection direction) + { + int steps, targetPosition; + + switch (direction) + { + case Player::MovementDirection::FORWARD: + steps = 1; + + break; + case Player::MovementDirection::BACKWARD: + steps = -1; + break; + default: + steps = 0; + break; + } + + targetPosition = player_model->getPosition() + steps; + + if (!isPositionValid(targetPosition)) + { + return; + } + + player_model->setPosition(targetPosition); + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::MOVE); + } + + void PlayerController::jump(MovementDirection direction) + { + int currentPosition = player_model->getPosition(); + BlockType box_value = ServiceLocator::getInstance()->getLevelService()->getCurrentBoxValue(currentPosition); + int steps, targetPosition; + switch (direction) + { + case Player::MovementDirection::FORWARD: + steps = static_cast(box_value); + break; + case Player::MovementDirection::BACKWARD: + steps = -static_cast(box_value); + break; + default: + steps = 0; + break; + } + targetPosition = currentPosition + steps; + if (isPositionValid(targetPosition)) + { + player_model->setPosition(targetPosition); + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::JUMP); + } + } + + bool PlayerController::isPositionValid(int targetPosition) + { + if (targetPosition >= 0 && targetPosition < Level::LevelData::number_of_box) + { + return true; + } + else + { + return false; + } + } + + void PlayerController::readInput() + { + if (event_service->pressedLeftArrowKey() || event_service->pressedAKey()) + { + if (event_service->heldSpaceKey()) + { + jump(MovementDirection::BACKWARD); + } + else + { + movePlayer(MovementDirection::BACKWARD); + } + } + else if (event_service->pressedRightArrowKey() || event_service->pressedDKey()) + { + if (event_service->heldSpaceKey()) + { + jump(MovementDirection::FORWARD); + } + else + { + movePlayer(MovementDirection::FORWARD); + } + } + + } + +} diff --git a/Array-Jumper/source/Player/PlayerModel.cpp b/Array-Jumper/source/Player/PlayerModel.cpp new file mode 100644 index 00000000..b4562136 --- /dev/null +++ b/Array-Jumper/source/Player/PlayerModel.cpp @@ -0,0 +1,46 @@ +#include "../../header/Player/PlayerModel.h" + + +namespace Player { + void PlayerModel::initialize() + { + current_lives = max_lives; + } + void PlayerModel::update() + { + } + int PlayerModel::getPosition() + { + return current_position; + } + void PlayerModel::setPosition(int player_position) + { + current_position = player_position; + } + PlayerState PlayerModel::getPlayerState() + { + return player_state; + } + void PlayerModel::setPlayerState(PlayerState state) + { + player_state = state; + } + void PlayerModel::resetPlayer() + { + current_position = 0; + player_state = PlayerState::ALIVE; + current_lives = max_lives; + } + int PlayerModel::getCurrentLives() + { + return current_lives; + } + void PlayerModel::decrementLife() + { + current_lives--; + } + void PlayerModel::resetPositon() + { + current_position = 0; + } +} \ No newline at end of file diff --git a/Array-Jumper/source/Player/PlayerService.cpp b/Array-Jumper/source/Player/PlayerService.cpp new file mode 100644 index 00000000..99a78c1e --- /dev/null +++ b/Array-Jumper/source/Player/PlayerService.cpp @@ -0,0 +1,46 @@ +#include "../../header/Player/PlayerService.h" +#include "../../header/Player/PlayerController.h" +namespace Player +{ + Player::PlayerService::PlayerService() + { + player_conroller = new PlayerController(); + } + PlayerService::~PlayerService() + { + delete(player_conroller); + } + void PlayerService::initialize() + { + player_conroller->initialize(); + } + void PlayerService::update() + { + player_conroller->update(); + } + void PlayerService::render() + { + player_conroller->render(); + } + void PlayerService::takeDamage() + { + player_conroller->takeDamage(); + } + int PlayerService::getCurrentPosition() + { + return player_conroller->getCurrentPosition(); + } + void PlayerService::levelComplete() + { + player_conroller->levelComplete(); + } + int PlayerService::getCurrentLives() + { + return player_conroller->getCurrentLives(); + } + void PlayerService::onDeath() + { + + player_conroller->onDeath(); + } +} \ No newline at end of file diff --git a/Array-Jumper/source/Player/PlayerView.cpp b/Array-Jumper/source/Player/PlayerView.cpp new file mode 100644 index 00000000..93a0921e --- /dev/null +++ b/Array-Jumper/source/Player/PlayerView.cpp @@ -0,0 +1,70 @@ +#include "../../header/Player/PlayerView.h" +#include "../../header/Global/Config.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Player/PlayerController.h" +#include "../../header/Player/PlayerModel.h" +#include "../../header/Level/LevelModel.h" + +namespace Player +{ + using namespace Global; + + Player::PlayerView::PlayerView(PlayerController* controller) + { + player_controller = controller; + game_window = nullptr; + player_image = new UI::UIElement::ImageView(); + } + PlayerView::~PlayerView() + { + } + void PlayerView::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + loadImage(); + } + void PlayerView::update() + { + updatePlayerPosition(); + } + void PlayerView::render() + { + switch (player_controller->getPlayerState()) + { + case PlayerState::ALIVE: + drawPlayer(); + default: + break; + } + } + + void PlayerView::initializePlayerImage() + { + player_image->initialize(Config::character_texture_path, player_width, player_height, sf::Vector2f(0, 0)); + } + void PlayerView::drawPlayer() + { + player_image->render(); + } + void PlayerView::loadImage() + { + calculatePlayerDimension(); + initializePlayerImage(); + } + void PlayerView::calculatePlayerDimension() + { + current_box_dimensions = ServiceLocator::getInstance()->getLevelService()->getBoxDimension(); + player_width = current_box_dimensions.box_width; + player_height = current_box_dimensions.box_height; + } + void PlayerView::updatePlayerPosition() + { + player_image->setPosition(calculatePlayerPosition()); + } + sf::Vector2f PlayerView::calculatePlayerPosition() + { + float xPosition = current_box_dimensions.box_spacing + static_cast(player_controller->getCurrentPosition()) * (current_box_dimensions.box_width + current_box_dimensions.box_spacing); + float yPosition = static_cast(game_window->getSize().y) - current_box_dimensions.box_height - current_box_dimensions.bottom_offset - player_height; + return sf::Vector2f(xPosition, yPosition); + } +} \ No newline at end of file diff --git a/Array-Jumper/source/UI/Credits/CreditsScreenUIController.cpp b/Array-Jumper/source/UI/Credits/CreditsScreenUIController.cpp index d38ff19b..06011123 100644 --- a/Array-Jumper/source/UI/Credits/CreditsScreenUIController.cpp +++ b/Array-Jumper/source/UI/Credits/CreditsScreenUIController.cpp @@ -31,6 +31,7 @@ namespace UI void CreditsScreenUIController::createText() { title_text = new TextView(); + won_textView = new TextView(); } void CreditsScreenUIController::createImage() @@ -56,6 +57,9 @@ namespace UI { title_text->initialize(game_title, sf::Vector2f(0, text_top_offset), FontType::BUBBLE_BOBBLE, font_size, text_color); title_text->setTextCentreAligned(); + + won_textView->initialize(won_text, sf::Vector2f(0, text_top_offset + 150), FontType::BUBBLE_BOBBLE, font_size, text_color); + won_textView->setTextCentreAligned(); } void CreditsScreenUIController::initializeBackgroundImage() @@ -98,6 +102,7 @@ namespace UI menu_button->update(); quit_button->update(); title_text->update(); + won_textView->update(); } void CreditsScreenUIController::render() @@ -106,6 +111,7 @@ namespace UI menu_button->render(); quit_button->render(); title_text->render(); + won_textView->render(); } void CreditsScreenUIController::show() @@ -114,10 +120,12 @@ namespace UI menu_button->show(); quit_button->show(); title_text->show(); + won_textView->show(); } void CreditsScreenUIController::destroy() { + delete (won_textView); delete (title_text); delete (menu_button); delete (quit_button); diff --git a/Array-Jumper/source/UI/GameOver/GameOverController.cpp b/Array-Jumper/source/UI/GameOver/GameOverController.cpp new file mode 100644 index 00000000..efe69827 --- /dev/null +++ b/Array-Jumper/source/UI/GameOver/GameOverController.cpp @@ -0,0 +1,134 @@ +#include "../../header/UI/GameOver/GameOverController.h" +#include "../../header/Main/GameService.h" +#include "../../header/Graphics/GraphicService.h" +#include "../../header/Sound/SoundService.h" +#include "../../header/Event/EventService.h" +#include "../../header/Global/Config.h" +#include "../../header/Global/ServiceLocator.h" + +namespace UI +{ + namespace GameOverUI + { + using namespace Global; + using namespace UIElement; + using namespace Main; + using namespace Graphics; + using namespace Sound; + + GameOverController::GameOverController() + { + createText(); + createImage(); + createButtons(); + } + + GameOverController::~GameOverController() + { + destroy(); + } + + void GameOverController::createText() + { + title_text = new TextView(); + gameover_text = new TextView(); + } + + void GameOverController::createImage() + { + background_image = new ImageView(); + } + + void GameOverController::createButtons() + { + menu_button = new ButtonView(); + quit_button = new ButtonView(); + } + + void GameOverController::initialize() + { + initializeText(); + initializeBackgroundImage(); + initializeButtons(); + registerButtonCallback(); + } + + void GameOverController::initializeText() + { + title_text->initialize(game_title, sf::Vector2f(0, text_top_offset), FontType::BUBBLE_BOBBLE, font_size, text_color); + gameover_text->initialize(game_over_text, sf::Vector2f(0, text_top_offset + 150), FontType::BUBBLE_BOBBLE, font_size, text_color); + title_text->setTextCentreAligned(); + gameover_text->setTextCentreAligned(); + } + + void GameOverController::initializeBackgroundImage() + { + sf::RenderWindow* game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + + background_image->initialize(Config::array_jumper_bg_texture_path, game_window->getSize().x, game_window->getSize().y, sf::Vector2f(0, 0)); + background_image->setImageAlpha(background_alpha); + } + + void GameOverController::initializeButtons() + { + menu_button->initialize("Menu Button", Config::menu_button_texture_path, button_width, button_height, sf::Vector2f(0, menu_button_y_position)); + quit_button->initialize("Quit Button", Config::quit_button_texture_path, button_width, button_height, sf::Vector2f(0, quit_button_y_position)); + + menu_button->setCentreAlinged(); + quit_button->setCentreAlinged(); + } + + void GameOverController::registerButtonCallback() + { + menu_button->registerCallbackFuntion(std::bind(&GameOverController::menuButtonCallback, this)); + quit_button->registerCallbackFuntion(std::bind(&GameOverController::quitButtonCallback, this)); + } + + void GameOverController::menuButtonCallback() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BUTTON_CLICK); + GameService::setGameState(GameState::MAIN_MENU); + } + + void GameOverController::quitButtonCallback() + { + ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->close(); + } + + void GameOverController::update() + { + background_image->update(); + menu_button->update(); + quit_button->update(); + title_text->update(); + gameover_text->update(); + } + + void GameOverController::render() + { + background_image->render(); + menu_button->render(); + quit_button->render(); + title_text->render(); + gameover_text->render(); + } + + void GameOverController::show() + { + background_image->show(); + menu_button->show(); + quit_button->show(); + title_text->show(); + gameover_text->show(); + } + + void GameOverController::destroy() + { + delete (title_text); + delete (gameover_text); + delete (menu_button); + delete (quit_button); + delete (background_image); + } + } +} diff --git a/Array-Jumper/source/UI/GamePlay/GameplayUIController.cpp b/Array-Jumper/source/UI/GamePlay/GameplayUIController.cpp new file mode 100644 index 00000000..6211de8a --- /dev/null +++ b/Array-Jumper/source/UI/GamePlay/GameplayUIController.cpp @@ -0,0 +1,61 @@ +#include "../../header/UI/GamePlay/GameplayUIController.h" +#include "../../header/Global/ServiceLocator.h" +#include + +namespace GamePlayUI +{ + using namespace Global; + using namespace UI::UIElement; + GameplayUIController::GameplayUIController() + { + m_liveTextView = nullptr; + createTextView(); + } + GameplayUIController::~GameplayUIController() + { + delete(m_liveTextView); + } + void GameplayUIController::initialize() + { + initializeTextView(); + } + void GameplayUIController::update() + { + updateTextView(); + } + void GameplayUIController::render() + { + m_liveTextView->render(); + m_levelTextView->render(); + } + void GameplayUIController::createTextView() + { + m_liveTextView = new UI::UIElement::TextView(); + m_levelTextView = new UI::UIElement::TextView(); + } + void GameplayUIController::initializeTextView() + { + float window_width = ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->getSize().x; + std::cout << window_width <initialize("0", sf::Vector2f(x_position_live, y_position), UI::UIElement::FontType::BUBBLE_BOBBLE, font_size, sf::Color::White); + m_levelTextView->initialize("0", sf::Vector2f(x_position_level, y_position), UI::UIElement::FontType::BUBBLE_BOBBLE, font_size, sf::Color::White); + } + void GameplayUIController::updateTextView() + { + int level = ServiceLocator::getInstance()->getLevelService()->getCurrentLevelIndex(); + std::string level_count_string = "LEVEL: " + std::to_string(level); + + int lives = ServiceLocator::getInstance()->getPlayerService()->getCurrentLives(); + std::string life_count_string = "LIFE: " + std::to_string(lives); + + m_levelTextView->setText(level_count_string); + m_liveTextView->setText(life_count_string); + m_levelTextView->update(); + m_liveTextView->update(); + } + + +} \ No newline at end of file diff --git a/Array-Jumper/source/UI/MainMenu/MainMenuUIController.cpp b/Array-Jumper/source/UI/MainMenu/MainMenuUIController.cpp index b3c74893..7a572427 100644 --- a/Array-Jumper/source/UI/MainMenu/MainMenuUIController.cpp +++ b/Array-Jumper/source/UI/MainMenu/MainMenuUIController.cpp @@ -75,6 +75,7 @@ namespace UI void MainMenuUIController::playButtonCallback() { ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BUTTON_CLICK); + GameService::setGameState(GameState::GAMEPLAY); } void MainMenuUIController::instructionsButtonCallback() diff --git a/Array-Jumper/source/UI/UIService.cpp b/Array-Jumper/source/UI/UIService.cpp index 0623d796..f7e733e2 100644 --- a/Array-Jumper/source/UI/UIService.cpp +++ b/Array-Jumper/source/UI/UIService.cpp @@ -6,6 +6,7 @@ + namespace UI { using namespace Main; @@ -15,6 +16,8 @@ namespace UI using namespace Instructions; using namespace Global; using namespace UIElement; + using namespace GamePlayUI; + using namespace GameOverUI; UIService::UIService() { @@ -22,6 +25,8 @@ namespace UI main_menu_ui_controller = nullptr; credits_screen_ui_controller = nullptr; instructions_ui_controller = nullptr; + gameplay_ui_controller = nullptr; + gameover_ui_controller = nullptr; createControllers(); } @@ -37,6 +42,8 @@ namespace UI main_menu_ui_controller = new MainMenuUIController(); credits_screen_ui_controller = new CreditsScreenUIController(); instructions_ui_controller = new InstructionsUIController(); + gameplay_ui_controller = new GameplayUIController(); + gameover_ui_controller = new GameOverController(); } void UIService::initialize() @@ -51,6 +58,8 @@ namespace UI main_menu_ui_controller->initialize(); credits_screen_ui_controller->initialize(); instructions_ui_controller->initialize(); + gameplay_ui_controller->initialize(); + gameover_ui_controller->initialize(); } void UIService::initializeUIElements() @@ -74,7 +83,14 @@ namespace UI case GameState::CREDITS: credits_screen_ui_controller->update(); break; + case GameState::GAMEPLAY: + gameplay_ui_controller->update(); + break; + case GameState::GAMEOVER: + gameover_ui_controller->update(); + break; } + } void UIService::render() @@ -93,6 +109,12 @@ namespace UI case GameState::CREDITS: credits_screen_ui_controller->render(); break; + case GameState::GAMEPLAY: + gameplay_ui_controller->render(); + break; + case GameState::GAMEOVER: + gameover_ui_controller->render(); + break; } } @@ -107,5 +129,7 @@ namespace UI delete(main_menu_ui_controller); delete(credits_screen_ui_controller); delete(instructions_ui_controller); + delete(gameplay_ui_controller); + delete(gameover_ui_controller); } } \ No newline at end of file