diff --git a/Array-Jumper/Array-Jumper.vcxproj b/Array-Jumper/Array-Jumper.vcxproj index 658ea835..89a151b9 100644 --- a/Array-Jumper/Array-Jumper.vcxproj +++ b/Array-Jumper/Array-Jumper.vcxproj @@ -1,4 +1,4 @@ - + @@ -133,14 +133,25 @@ + + + + + + + + + + + @@ -152,12 +163,26 @@ + + + + + + + + + + + + + + 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..0ae19118 --- /dev/null +++ b/Array-Jumper/header/GamePlay/GamePlayController.h @@ -0,0 +1,29 @@ +#pragma once +#include "../../header/Level/BlockType.h" + +namespace GamePlay +{ + + class GamePlayController + { + public: + GamePlayController(); + ~GamePlayController(); + + void initialize(); + void update(); + void render(); + void onDeath(); + + + 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/LevelController.h b/Array-Jumper/header/Level/LevelController.h new file mode 100644 index 00000000..00a9c2fa --- /dev/null +++ b/Array-Jumper/header/Level/LevelController.h @@ -0,0 +1,25 @@ +#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(); + + 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..1f33d8a7 --- /dev/null +++ b/Array-Jumper/header/Level/LevelData.h @@ -0,0 +1,26 @@ +#pragma once +#include "../../header/Level/BlockType.h" + +namespace Level +{ + struct LevelData + { + static const int number_of_box = 10; + BlockType level_boxes[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 + }; + + + + }; +} + diff --git a/Array-Jumper/header/Level/LevelModel.h b/Array-Jumper/header/Level/LevelModel.h new file mode 100644 index 00000000..d96906e7 --- /dev/null +++ b/Array-Jumper/header/Level/LevelModel.h @@ -0,0 +1,29 @@ +#pragma once +#include "../../header/Level/LevelData.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); + + private: + LevelData current_level_data; + }; + + +} \ 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..54361051 --- /dev/null +++ b/Array-Jumper/header/Level/LevelService.h @@ -0,0 +1,25 @@ +#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); + + 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/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..4cc1ce28 --- /dev/null +++ b/Array-Jumper/header/Player/PlayerController.h @@ -0,0 +1,43 @@ +#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(); + + 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/GamePlay/GameplayUIController.h b/Array-Jumper/header/UI/GamePlay/GameplayUIController.h new file mode 100644 index 00000000..b3762a1a --- /dev/null +++ b/Array-Jumper/header/UI/GamePlay/GameplayUIController.h @@ -0,0 +1,30 @@ +#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 = 100.f; + const float right_offset = 250.f; + + UI::UIElement::TextView* m_liveTextView; + void createLiveTextView(); + void initializeLiveTextView(); + void updateLiveTextView(); + + }; + + +} \ No newline at end of file diff --git a/Array-Jumper/header/UI/UIService.h b/Array-Jumper/header/UI/UIService.h index 8db7e889..568b641e 100644 --- a/Array-Jumper/header/UI/UIService.h +++ b/Array-Jumper/header/UI/UIService.h @@ -5,9 +5,11 @@ #include "../../header/UI/MainMenu/MainMenuUIController.h" #include "../../header/UI/Instructions/InstructionsUIController.h" #include "../../header/UI/Credits/CreditsScreenUIController.h" +#include "../../header/UI/GamePlay/GameplayUIController.h" namespace UI { + class UIService { @@ -16,6 +18,7 @@ namespace UI MainMenu::MainMenuUIController* main_menu_ui_controller; Credits::CreditsScreenUIController* credits_screen_ui_controller; Instructions::InstructionsUIController* instructions_ui_controller; + GamePlayUI::GameplayUIController* gameplay_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..3d3e8a97 --- /dev/null +++ b/Array-Jumper/source/GamePlay/GamePlayController.cpp @@ -0,0 +1,87 @@ +#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() +{ + GameService::setGameState(GameState::CREDITS); + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::LEVEL_COMPLETE); + ServiceLocator::getInstance()->getPlayerService()->levelComplete(); +} + +void GamePlay::GamePlayController::gameOver() +{ + GameService::setGameState(GameState::CREDITS); + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::DEATH); +} + +void GamePlay::GamePlayController::onDeath() +{ + gameOver(); +} 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..e42a1c7d --- /dev/null +++ b/Array-Jumper/source/Level/LevelController.cpp @@ -0,0 +1,36 @@ +#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(); + } +} \ 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..e41a3ecd --- /dev/null +++ b/Array-Jumper/source/Level/LevelModel.cpp @@ -0,0 +1,15 @@ +#include "../../header/Level/LevelModel.h" + +namespace Level +{ + Level::LevelModel::LevelModel() + { + } + LevelModel::~LevelModel() + { + } + BlockType LevelModel::getCurrentBoxValue(int currentPosition) + { + return current_level_data.level_boxes[currentPosition]; + } +} \ 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..ca592795 --- /dev/null +++ b/Array-Jumper/source/Level/LevelService.cpp @@ -0,0 +1,34 @@ +#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); + } +} \ 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..19f116a0 --- /dev/null +++ b/Array-Jumper/source/Level/LevelView.cpp @@ -0,0 +1,168 @@ +#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..c1b9a015 --- /dev/null +++ b/Array-Jumper/source/Player/PlayerController.cpp @@ -0,0 +1,178 @@ +#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(); + + } + } + + 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..cb44f3e8 --- /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->takeDamage(); + } + 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/GamePlay/GameplayUIController.cpp b/Array-Jumper/source/UI/GamePlay/GameplayUIController.cpp new file mode 100644 index 00000000..6fabae1a --- /dev/null +++ b/Array-Jumper/source/UI/GamePlay/GameplayUIController.cpp @@ -0,0 +1,48 @@ +#include "../../header/UI/GamePlay/GameplayUIController.h" +#include "../../header/Global/ServiceLocator.h" + +namespace GamePlayUI +{ + using namespace Global; + using namespace UI::UIElement; + GameplayUIController::GameplayUIController() + { + m_liveTextView = nullptr; + createLiveTextView(); + } + GameplayUIController::~GameplayUIController() + { + delete(m_liveTextView); + } + void GameplayUIController::initialize() + { + initializeLiveTextView(); + } + void GameplayUIController::update() + { + updateLiveTextView(); + } + void GameplayUIController::render() + { + m_liveTextView->render(); + } + void GameplayUIController::createLiveTextView() + { + m_liveTextView = new UI::UIElement::TextView(); + } + void GameplayUIController::initializeLiveTextView() + { + float window_width = ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->getSize().x; + float x_position = window_width - right_offset; + float y_position = top_offset; + m_liveTextView->initialize("0", sf::Vector2f(x_position, y_position), UI::UIElement::FontType::BUBBLE_BOBBLE, font_size, sf::Color::White); + } + void GameplayUIController::updateLiveTextView() + { + int lives = ServiceLocator::getInstance()->getPlayerService()->getCurrentLives(); + std::string life_count_string = "LIFE: " + std::to_string(lives); + + m_liveTextView->setText(life_count_string); + 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..2f9f53a2 100644 --- a/Array-Jumper/source/UI/UIService.cpp +++ b/Array-Jumper/source/UI/UIService.cpp @@ -15,6 +15,7 @@ namespace UI using namespace Instructions; using namespace Global; using namespace UIElement; + using namespace GamePlayUI; UIService::UIService() { @@ -22,6 +23,7 @@ namespace UI main_menu_ui_controller = nullptr; credits_screen_ui_controller = nullptr; instructions_ui_controller = nullptr; + gameplay_ui_controller = nullptr; createControllers(); } @@ -37,6 +39,7 @@ namespace UI main_menu_ui_controller = new MainMenuUIController(); credits_screen_ui_controller = new CreditsScreenUIController(); instructions_ui_controller = new InstructionsUIController(); + gameplay_ui_controller = new GameplayUIController(); } void UIService::initialize() @@ -51,6 +54,7 @@ namespace UI main_menu_ui_controller->initialize(); credits_screen_ui_controller->initialize(); instructions_ui_controller->initialize(); + gameplay_ui_controller->initialize(); } void UIService::initializeUIElements() @@ -74,7 +78,11 @@ namespace UI case GameState::CREDITS: credits_screen_ui_controller->update(); break; + case GameState::GAMEPLAY: + gameplay_ui_controller->update(); + break; } + } void UIService::render() @@ -93,6 +101,9 @@ namespace UI case GameState::CREDITS: credits_screen_ui_controller->render(); break; + case GameState::GAMEPLAY: + gameplay_ui_controller->render(); + break; } } @@ -107,5 +118,6 @@ namespace UI delete(main_menu_ui_controller); delete(credits_screen_ui_controller); delete(instructions_ui_controller); + delete(gameplay_ui_controller); } } \ No newline at end of file