diff --git a/Space-Invaders/Header/Bullet/BulletConfig.h b/Space-Invaders/Header/Bullet/BulletConfig.h new file mode 100644 index 000000000..41c2e7f52 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletConfig.h @@ -0,0 +1,17 @@ +#pragma once + +namespace Bullet +{ + enum class BulletType + { + LASER_BULLET, + TORPEDO, + FROST_BULLET, + }; + + enum class MovementDirection + { + UP, + DOWN, + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletController.h b/Space-Invaders/Header/Bullet/BulletController.h new file mode 100644 index 000000000..3826827c6 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletController.h @@ -0,0 +1,33 @@ +#pragma once +#include"../../Header/Projectile/IProjectile.h" +#include"../../Header/Bullet/BulletConfig.h" + +namespace Bullet +{ + class BulletView; + class BulletModel; + enum class BulletType; + + class BulletController :public Projectile::IProjectile + { + protected: + BulletView* bullet_view; + BulletModel* bullet_model; + + void updateProjectilePosition() override; + + void moveUP(); + void moveDown(); + void handleOutOfBounds(); + + public: + BulletController(BulletType type); + virtual ~BulletController() override; + void initialize(sf::Vector2f position, Bullet::MovementDirection direction)override; + void update() override; + void render() override; + + sf::Vector2f getProjectilePosition() override; + BulletType getBulletType(); + }; +} diff --git a/Space-Invaders/Header/Bullet/BulletModel.h b/Space-Invaders/Header/Bullet/BulletModel.h new file mode 100644 index 000000000..941e5d6da --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletModel.h @@ -0,0 +1,36 @@ +#pragma once +#include + +namespace Bullet +{ + enum class BulletType; + enum class MovementDirection; + + class BulletModel + { + private: + float movement_speed = 300.f; + sf::Vector2f bullet_position; + + BulletType bullet_type; + MovementDirection movement_direction; + + public: + BulletModel(BulletType type); + ~BulletModel(); + + void initialize(sf::Vector2f position, MovementDirection direction); + + sf::Vector2f getBulletPosition(); + void setBulletPosition(sf::Vector2f position); + + BulletType getBulletType(); + void setBulletType(BulletType type); + + MovementDirection getMovementDirection(); + void setMovementDirection(MovementDirection direction); + + float getMovementSpeed(); + void setMovementSpeed(float speed); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletService.h b/Space-Invaders/Header/Bullet/BulletService.h new file mode 100644 index 000000000..6c0508584 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletService.h @@ -0,0 +1,33 @@ +#pragma once +#include +#include"SFML/System/Vector2.hpp" +#include"../../Header/Projectile/IProjectile.h" + +namespace Bullet +{ + class BulletController; + enum class BulletType; + enum class MovementDirection; + + class BulletService + { + private: + + std::vectorbullet_list; + + BulletController* createBullet(BulletType bullet_type); + void destroy(); + + public: + BulletService(); + virtual ~BulletService(); + + void initialize(); + void update(); + void render(); + + BulletController* spwanBullet(BulletType bullet_type, sf::Vector2f position, MovementDirection direction); + void destroyBullet(BulletController* bullet_controller); + }; + +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/BulletView.h b/Space-Invaders/Header/Bullet/BulletView.h new file mode 100644 index 000000000..bea76f635 --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletView.h @@ -0,0 +1,34 @@ +#pragma once +#include +#include "../../Header/UI/UIElement/ImageView.h" + +namespace Bullet +{ + class BulletController; + enum class BulletType; + + class BulletView + { + private: + const float bullet_sprite_width = 18.f; + const float bullet_sprite_height = 18.f; + + BulletController* bullet_controller; + UI::UIElement::ImageView* bullet_image; + + void initializeImage(); + void createUIElements(); + sf::String getBulletTexturePath(); + + void destroy(); + + public: + BulletView(); + ~BulletView(); + + void initialize(BulletController* controller); + void update(); + void render(); + + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/Controllers/FrostBulletController.h b/Space-Invaders/Header/Bullet/Controllers/FrostBulletController.h new file mode 100644 index 000000000..0af4a93b8 --- /dev/null +++ b/Space-Invaders/Header/Bullet/Controllers/FrostBulletController.h @@ -0,0 +1,20 @@ +#pragma once +#include"../../Header/Bullet/BulletController.h" + +namespace Bullet +{ + namespace Controller + { + class FrostBulletController :public BulletController + { + private: + const float frost_bullet_movement_speed = 500.f; + + public: + FrostBulletController(BulletType type); + ~FrostBulletController(); + + void initialize(sf::Vector2f position, MovementDirection direction)override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/Controllers/LaserBulletController.h b/Space-Invaders/Header/Bullet/Controllers/LaserBulletController.h new file mode 100644 index 000000000..5e9ae4aea --- /dev/null +++ b/Space-Invaders/Header/Bullet/Controllers/LaserBulletController.h @@ -0,0 +1,17 @@ +#pragma once +#include"../../Header/Bullet/BulletController.h" + +namespace Bullet +{ + namespace Controller + { + class LaserBulletController :public BulletController + { + public: + LaserBulletController(BulletType type); + ~LaserBulletController(); + + void initialize(sf::Vector2f position, MovementDirection)override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Bullet/Controllers/TorpedoeController.h b/Space-Invaders/Header/Bullet/Controllers/TorpedoeController.h new file mode 100644 index 000000000..b92a72d1b --- /dev/null +++ b/Space-Invaders/Header/Bullet/Controllers/TorpedoeController.h @@ -0,0 +1,20 @@ +#pragma once +#include"../../Header/Bullet/BulletController.h" + +namespace Bullet +{ + namespace Controller + { + class TorpedoController :public BulletController + { + private: + const float torpedo_movement_speed = 200.f; + + public: + TorpedoController(BulletType type); + ~TorpedoController(); + + void initialize(sf::Vector2f position, MovementDirection direction)override; + }; + } +} diff --git a/Space-Invaders/Header/Collectible/ICollectible.h b/Space-Invaders/Header/Collectible/ICollectible.h new file mode 100644 index 000000000..eac7d98f9 --- /dev/null +++ b/Space-Invaders/Header/Collectible/ICollectible.h @@ -0,0 +1,19 @@ +#pragma once +#include + +namespace Collectible +{ + class ICollectible + { + public: + virtual void onCollected() = 0; + virtual void initialize(sf::Vector2f position) = 0; + virtual void update() = 0; + virtual void render() = 0; + virtual sf::Vector2f getCollectiblePosition() = 0; + + virtual ~ICollectible() {}; + }; + + +} diff --git a/Space-Invaders/Header/Elements/Bunker/BunkerController.h b/Space-Invaders/Header/Elements/Bunker/BunkerController.h new file mode 100644 index 000000000..90209c29c --- /dev/null +++ b/Space-Invaders/Header/Elements/Bunker/BunkerController.h @@ -0,0 +1,29 @@ +#pragma once +#include +#include"../../Header/Elements/Bunker/BunkerModel.h" + +namespace Element +{ + namespace Bunker + { + class BunkerView; + + class BunkerController + { + private: + BunkerView* bunker_view; + BunkerData bunker_data; + + public: + BunkerController(); + ~BunkerController(); + + void initialize(BunkerData data); + void update(); + void render(); + + sf::Vector2f getBunkerPosition(); + }; + } + +} \ No newline at end of file diff --git a/Space-Invaders/Header/Elements/Bunker/BunkerModel.h b/Space-Invaders/Header/Elements/Bunker/BunkerModel.h new file mode 100644 index 000000000..5e1a0f50b --- /dev/null +++ b/Space-Invaders/Header/Elements/Bunker/BunkerModel.h @@ -0,0 +1,14 @@ +#pragma once +#include + +namespace Element +{ + namespace Bunker + { + struct BunkerData + { + sf::Vector2f position;BunkerData(); + BunkerData(sf::Vector2f position); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Elements/Bunker/BunkerView.h b/Space-Invaders/Header/Elements/Bunker/BunkerView.h new file mode 100644 index 000000000..691f8ef5d --- /dev/null +++ b/Space-Invaders/Header/Elements/Bunker/BunkerView.h @@ -0,0 +1,35 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Element +{ + namespace Bunker + { + class BunkerController; + + class BunkerView + { + private: + const float bunker_sprite_width = 80.f; + const float bunker_sprite_height = 80.f; + + BunkerController* bunker_controller; + UI::UIElement::ImageView* bunker_image; + + void createUIElements(); + void initializeImage(); + sf::String getBunkerTexturePath(); + + void destroy(); + + public: + BunkerView(); + ~BunkerView(); + + void initialize(BunkerController* controller); + void update(); + void render(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Elements/ElementService.h b/Space-Invaders/Header/Elements/ElementService.h new file mode 100644 index 000000000..3f04e5f31 --- /dev/null +++ b/Space-Invaders/Header/Elements/ElementService.h @@ -0,0 +1,36 @@ +#pragma once +#include +#include +#include"../../Header/Elements/Bunker/BunkerController.h" +#include"../../Header/Elements/Bunker/BunkerModel.h" + +namespace Element +{ + class BunkerController; + + + class ElementService + { + private: + const std::vectorbunker_data_list = { + Bunker::BunkerData(sf::Vector2f(130.f,800.f)), + Bunker::BunkerData(sf::Vector2f(430.0f,800.f)), + Bunker::BunkerData(sf::Vector2f(730.0f,800.f)), + Bunker::BunkerData(sf::Vector2f(1130.0f,800.f)), + Bunker::BunkerData(sf::Vector2f(1430.f,800.f)), + Bunker::BunkerData(sf::Vector2f(1730.0f,800.f)) + }; + + std::vector bunker_list; + + void destroy(); + + public: + ElementService(); + virtual ~ElementService(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/Controllers/SubZeroController.h b/Space-Invaders/Header/Enemy/Controllers/SubZeroController.h new file mode 100644 index 000000000..9718d5303 --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/SubZeroController.h @@ -0,0 +1,25 @@ +#pragma once +#include "../../header/Enemy/EnemyController.h" + +namespace Enemy +{ + namespace Controller + { + class SubzeroController : public EnemyController + { + private: + float vertical_movement_speed = 100.f; + float subzero_rate_of_fire = 2.f; + + void move() override; + void moveDown(); + void fireBullet() override; + + public: + SubzeroController(EnemyType type); + ~SubzeroController(); + + void initialize() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/Controllers/ThunderSnakeController.h b/Space-Invaders/Header/Enemy/Controllers/ThunderSnakeController.h new file mode 100644 index 000000000..c20dfdb10 --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/ThunderSnakeController.h @@ -0,0 +1,27 @@ +#pragma once +#include"../../Header/Enemy/EnemyController.h" + +namespace Enemy +{ + namespace Controller + { + class ThunderSnakeController : public EnemyController + { + private: + float horizontal_movement_speed = 250.f; + float vertical_movement_speed = 25.f; + float thunder_snake_rate_of_fire = 2.f; + + void move() override; + void moveLeft(); + void moveRight(); + void fireBullet() override; + + public: + ThunderSnakeController(EnemyType type); + ~ThunderSnakeController(); + + void initialize() override; + }; + } +} diff --git a/Space-Invaders/Header/Enemy/Controllers/UFOController.h b/Space-Invaders/Header/Enemy/Controllers/UFOController.h new file mode 100644 index 000000000..834012a0a --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/UFOController.h @@ -0,0 +1,26 @@ +#pragma once +#include"../../Header/Enemy/EnemyController.h" +#include"../../Header/Powerup/PowerupConfig.h" + +namespace Enemy +{ + namespace Controller + { + class UFOController : public EnemyController + { + private: + void move() override; + void moveLeft(); + void moveRight(); + + void fireBullet() override; + Powerup::PowerupType getRandomPowerupType(); + + public: + UFOController(EnemyType type); + ~UFOController(); + + void initialize() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/Controllers/ZapperController.h b/Space-Invaders/Header/Enemy/Controllers/ZapperController.h new file mode 100644 index 000000000..9fb87271a --- /dev/null +++ b/Space-Invaders/Header/Enemy/Controllers/ZapperController.h @@ -0,0 +1,27 @@ +#pragma once +#include "../../header/Enemy/EnemyController.h" + +namespace Enemy +{ + namespace Controller + { + class ZapperController : public EnemyController + { + private: + float vertical_travel_distance = 100.f; + float zapper_rate_of_fire = 2.f; + + void move() override; + void moveLeft(); + void moveRight(); + void moveDown(); + void fireBullet() override; + + public: + ZapperController(EnemyType type); + ~ZapperController(); + + void initialize() override; + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyConfig.h b/Space-Invaders/Header/Enemy/EnemyConfig.h new file mode 100644 index 000000000..1684eff7f --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyConfig.h @@ -0,0 +1,28 @@ +#pragma once + +namespace Enemy +{ + enum class EnemyType + { + ZAPPER, + SUBZERO, + UFO, + THUNDER_SNAKE, + }; + + enum class EnemyState + { + PATROLLING, + ATTACK, + DEAD, + }; + + enum class MovementDirection + { + LEFT, + RIGHT, + DOWN, + DIAGONAL_LEFT, + DIAGONAL_RIGHT, + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyController.h b/Space-Invaders/Header/Enemy/EnemyController.h new file mode 100644 index 000000000..3b40f2353 --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyController.h @@ -0,0 +1,46 @@ +#pragma once +#include + +namespace Enemy +{ + class EnemyView; + class EnemyModel; + + enum class EnemyType; + enum class EnemyState; + + class EnemyController + { + protected: + + float vertical_movement_speed = 30.f; + float horizontal_movement_speed = 200.f; + + float rate_of_fire = 3.f; + float elapsed_fire_duration = 0.f; + + EnemyView* enemy_view; + EnemyModel* enemy_model; + + virtual void move() = 0; + + void updateFireTimer(); + void processBulletFire(); + virtual void fireBullet() = 0; + + sf::Vector2f getRandomInitialPosition(); + void handleOutOfBounds(); + + public: + EnemyController(EnemyType type); + virtual ~EnemyController(); + + virtual void initialize(); + void update(); + void render(); + + sf::Vector2f getEnemyPosition(); + EnemyState getEnemyState(); + EnemyType getEnemyType(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyModel.h b/Space-Invaders/Header/Enemy/EnemyModel.h new file mode 100644 index 000000000..1e0beffb1 --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyModel.h @@ -0,0 +1,49 @@ +#pragma once +#include + +namespace Enemy +{ + enum class EnemyType; + enum class MovementDirection; + enum class EnemyState; + + class EnemyModel + { + private: + sf::Vector2f reference_position = sf::Vector2f(50.f, 50.f); + sf::Vector2f enemy_position; + + MovementDirection movement_direction; + EnemyType enemy_type; + EnemyState enemy_state; + + public: + + const sf::Vector2f left_most_position = sf::Vector2f(50.f, 50.f); + const sf::Vector2f right_most_position = sf::Vector2f(1800.f, 50.f); + const sf::Vector2f barrel_position_offset = sf::Vector2f(20.f, 50.f); + + const float vertical_travel_distance = 100.f; + const float enemy_movement_speed = 250.0f; + + EnemyModel(EnemyType type); + ~EnemyModel(); + + void initialize(); + + sf::Vector2f getEnemyPosition(); + void setEnemyPosition(sf::Vector2f position); + + sf::Vector2f getReferencePosition(); + void setReferencePosition(sf::Vector2f position); + + EnemyState getEnemyState(); + void setEnemyState(EnemyState state); + + EnemyType getEnemyType(); + void setEnemyType(EnemyType type); + + MovementDirection getMovementDirection(); + void setMovementDirection(MovementDirection direction); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyService.h b/Space-Invaders/Header/Enemy/EnemyService.h new file mode 100644 index 000000000..38d1f565b --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyService.h @@ -0,0 +1,37 @@ +#pragma once +#include + +namespace Enemy +{ + class EnemyController; + enum class EnemyType; + + class EnemyService + { + private: + + const float spawn_interval = 3.f; + + std::vector enemy_list; + float spawn_timer; + + EnemyController* createEnemy(EnemyType enemy_type); + EnemyType getRandomEnemyType(); + + void updateSpawnTimer(); + void processEnemySpawn(); + + + public: + EnemyService(); + virtual ~EnemyService(); + + void initialize(); + void update(); + void render(); + + + EnemyController* spawnEnemy(); + void destroyEnemy(EnemyController* enemy_controller); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Enemy/EnemyView.h b/Space-Invaders/Header/Enemy/EnemyView.h new file mode 100644 index 000000000..3c1884a0c --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyView.h @@ -0,0 +1,35 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Enemy +{ + class EnemyController; + enum class EnemyType; + + class EnemyView + { + private: + + const float enemy_sprite_width = 60.f; + const float enemy_sprite_height = 60.f; + + EnemyController* enemy_controller; + UI::UIElement::ImageView* enemy_image; + + + void createUIElements(); + void initializeImage(); + sf::String getEnemyTexturePath(); + + void destroy(); + + public: + EnemyView(); + ~EnemyView(); + + void initialize(EnemyController* controller); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Event/EventService.h b/Space-Invaders/Header/Event/EventService.h new file mode 100644 index 000000000..11280206d --- /dev/null +++ b/Space-Invaders/Header/Event/EventService.h @@ -0,0 +1,50 @@ +#pragma once +#include +#include + +namespace Event +{ + enum class ButtonState + { + PRESSED, + HELD, + RELEASED, + }; + class EventService + { + private: + sf::Event game_event; + sf::RenderWindow* game_window; + + bool isGameWindowOpen(); + bool gameWindowWasClosed(); + bool hasQuitGame(); + + ButtonState left_mouse_button_state; + ButtonState right_mouse_button_state; + ButtonState left_arrow_button_state; + ButtonState right_arrow_button_state; + ButtonState A_button_state; + ButtonState D_button_state; + + void updateMouseButtonState(ButtonState& current_button_state, sf::Mouse::Button mouse_button); + void updateKeyboardButtonState(ButtonState& current_button_state, sf::Keyboard::Key keyboard_button); + + public: + EventService(); + ~EventService(); + + void initialize(); + void update(); + void processEvents(); + bool pressedEscapeKey(); + bool isKeyboardEvent(); + bool pressedLeftKey(); + bool pressedRightKey(); + bool pressedLeftMouseButton(); + bool pressedRightMouseButton(); + bool pressedAKey(); + bool pressedDKey(); + + }; +} diff --git a/Space-Invaders/Header/Gameplay/GameplayController.h b/Space-Invaders/Header/Gameplay/GameplayController.h new file mode 100644 index 000000000..558f836d2 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayController.h @@ -0,0 +1,21 @@ +#pragma once +#include + +namespace Gameplay +{ + class GameplayView; + + class GameplayController + { + private: + GameplayView* gameplay_view; + + public: + GameplayController(); + ~GameplayController(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Gameplay/GameplayService.h b/Space-Invaders/Header/Gameplay/GameplayService.h new file mode 100644 index 000000000..89537f758 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayService.h @@ -0,0 +1,20 @@ +#pragma once + +namespace Gameplay +{ + class GameplayController; + + class GameplayService + { + private: + GameplayController* gameplay_controller; + + public: + GameplayService(); + ~GameplayService(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Gameplay/GameplayView.h b/Space-Invaders/Header/Gameplay/GameplayView.h new file mode 100644 index 000000000..8b4f2f2c9 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayView.h @@ -0,0 +1,30 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Gameplay +{ + class GameplayView + { + private: + + const float background_sprite_width = 1920.0f; + const float background_sprite_height = 1080.0f; + + UI::UIElement::ImageView* background_image; + + void createUIElements(); + void initializeImage(); + sf::String getBackgroundTexturePath(); + + void destroy(); + + public: + GameplayView(); + ~GameplayView(); + + void initialize(); + void update(); + void render(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Global/Config.h b/Space-Invaders/Header/Global/Config.h new file mode 100644 index 000000000..59225e382 --- /dev/null +++ b/Space-Invaders/Header/Global/Config.h @@ -0,0 +1,39 @@ +#pragma once +#include + +namespace Global +{ + class Config + { + public: + static const sf::String outscal_logo_texture_path; + static const sf::String background_texture_path; + static const sf::String player_texture_path; + + static const sf::String zapper_texture_path; + static const sf::String thunder_snake_texture_path; + static const sf::String subzero_texture_path; + static const sf::String ufo_texture_path; + static const sf::String bunker_texture_path; + + static const sf::String shield_texture_path; + static const sf::String tripple_laser_texture_path; + static const sf::String rapid_fire_texture_path; + static const sf::String outscal_bomb_texture_path; + + static const sf::String laser_bullet_texture_path; + static const sf::String torpedoe_texture_path; + static const sf::String frost_beam_texture_path; + + static const sf::String play_button_texture_path; + static const sf::String instructions_button_texture_path; + static const sf::String quit_button_texture_path; + static const sf::String menu_button_texture_path; + + static const sf::String bubble_bobble_font_path; + static const sf::String DS_DIGIB_font_path; + + static const sf::String background_music_path; + static const sf::String button_click_sound_path; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Global/ServiceLocator.h b/Space-Invaders/Header/Global/ServiceLocator.h new file mode 100644 index 000000000..1651fac02 --- /dev/null +++ b/Space-Invaders/Header/Global/ServiceLocator.h @@ -0,0 +1,60 @@ +#pragma once +#include "../../Header/Graphic/GraphicService.h" +#include "../../Header/Event/EventService.h" +#include "../../Header/Player/PlayerService.h" +#include "../../Header/Time/TimeService.h" +#include "../../Header/UI/UIService.h" +#include "../../Header/Enemy/EnemyService.h" +#include "../../Header/Gameplay/GameplayService.h" +#include"../../Header/Elements/ElementService.h" +#include"../../Header/Sound/SoundService.h" +#include"../../Header/Bullet/BulletService.h" +#include"../../Header/Powerup/PowerupService.h" + +namespace Global +{ + class ServiceLocator + { + private: + + Graphic::GraphicService* graphic_service; + Event::EventService* event_service; + Player::PlayerService* player_service; + Time::TimeService* time_service; + UI::UIService* ui_service; + Enemy::EnemyService* enemy_service; + Gameplay::GameplayService* gameplay_service; + Element::ElementService* element_service; + Sound::SoundService* sound_service; + Bullet::BulletService* bullet_service; + Powerup::PowerupService* powerup_service; + + ServiceLocator(); + ~ServiceLocator(); + + // Private Methods: + void createServices(); // Creates instances of all services. + void clearAllServices(); // Deletes and deallocates memory for all services. + + public: + // Public Methods: + static ServiceLocator* getInstance(); // Provides a method to access the unique ServiceLocator instance (object). We will discuss this later. + + void initialize(); // Initializes the ServiceLocator. + void update(); // Updates all services. + void render(); // Renders using the services. + + // Methods to Get Specific Services: + Event::EventService* getEventService(); // Retrieve the EventService instance + Graphic::GraphicService* getGraphicService(); // Retrieve the GraphicService instance + Player::PlayerService* getPlayerService(); + Time::TimeService* getTimeService(); + UI::UIService* getUIService(); + Enemy::EnemyService* getEnemyService(); + Gameplay::GameplayService* getGameplayService(); + Element::ElementService* getElementService(); + Sound::SoundService* getSoundService(); + Bullet::BulletService* getBulletService(); + Powerup::PowerupService* getPowerupService(); + }; +} diff --git a/Space-Invaders/Header/Graphic/GraphicService.h b/Space-Invaders/Header/Graphic/GraphicService.h new file mode 100644 index 000000000..aee864fc5 --- /dev/null +++ b/Space-Invaders/Header/Graphic/GraphicService.h @@ -0,0 +1,38 @@ +#pragma once +#include + +namespace Graphic +{ + class GraphicService + { + private: + const std::string game_window_title = "Outscal Presents - Alien Invader"; + + const int game_window_width = 1920; + const int game_window_height = 1080; + const int frame_rate = 60; + + const sf::Color window_color = sf::Color::Black; + + sf::VideoMode* video_mode; + sf::RenderWindow* game_window; + + void setVideoMode(); + void onDestroy(); + + public: + GraphicService(); + ~GraphicService(); + + sf::RenderWindow* createGameWindow(); + + void initialize(); + void update(); + void render(); + bool isGameWindowOpen(); + + sf::RenderWindow* getGameWindow(); + sf::Color getWindowColor(); + + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Main/GameService.h b/Space-Invaders/Header/Main/GameService.h new file mode 100644 index 000000000..69037fd68 --- /dev/null +++ b/Space-Invaders/Header/Main/GameService.h @@ -0,0 +1,41 @@ +#pragma once +#include + +namespace Global +{ + class ServiceLocator; +} +namespace Main +{ + + enum class GameState + { + BOOT, + MAIN_MENU, + GAMEPLAY, + }; + class GameService + { + private: + + Global::ServiceLocator* service_locator; + sf::RenderWindow* game_window; + static GameState current_state; + + void showMainMenu(); + void initialize(); + void initializeVariables(); + void destroy(); + + public: + GameService(); + ~GameService(); + + void ignite(); + void update(); + void render(); + bool isRunning(); + static void setGameState(GameState new_state); + static GameState getGameState(); + }; +} diff --git a/Space-Invaders/Header/Player/PlayerController.h b/Space-Invaders/Header/Player/PlayerController.h new file mode 100644 index 000000000..ca203c8b9 --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerController.h @@ -0,0 +1,32 @@ +#pragma once +#include + +namespace Player +{ + enum class PlayerState; + class PlayerView; + class PlayerModel; + + class PlayerController + { + private: + PlayerModel* player_model; + PlayerView* player_view; + + void processPlayerInput(); + void moveLeft(); + void moveRight(); + void fireBullet(); + + public: + PlayerController(); + ~PlayerController(); + + + void initialize(); + void update(); + void render(); + + sf::Vector2f getPlayerPosition(); + }; +} diff --git a/Space-Invaders/Header/Player/PlayerModel.h b/Space-Invaders/Header/Player/PlayerModel.h new file mode 100644 index 000000000..0aace6b1c --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerModel.h @@ -0,0 +1,43 @@ +#pragma once +#include + +namespace Player +{ + enum class PlayerState + { + ALIVE, + DEAD, + }; + + class PlayerModel + { + private: + sf::Vector2f initial_player_position = sf::Vector2f(950.f, 950.f); + sf::Vector2f player_position; + + PlayerState player_state; + int player_score; + + public: + const float player_movement_speed = 350.0f; + const sf::Vector2f left_most_position = sf::Vector2f(50.f, 950.f); + const sf::Vector2f right_most_position = sf::Vector2f(1800.f, 950.f); + const sf::Vector2f barrel_position_offset = sf::Vector2f(20.f, 50.f); + + PlayerModel(); + ~PlayerModel(); + + void initialize(); + + void reset(); + + sf::Vector2f getPlayerPosition(); + void setPlayerPosition(sf::Vector2f position); + + int getPlayeScore(); + void setPlayerScore(int score); + + PlayerState getPlayerState(); + void setPlayerState(PlayerState state); + }; +} diff --git a/Space-Invaders/Header/Player/PlayerService.h b/Space-Invaders/Header/Player/PlayerService.h new file mode 100644 index 000000000..d2f19ebea --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerService.h @@ -0,0 +1,25 @@ +#pragma once +#include + +namespace Player +{ + class PlayerController; + + class PlayerService + { + + private: + + PlayerController* player_controller; + + public: + + PlayerService(); + ~PlayerService(); + + void initialize(); + void update(); + void render(); + }; +} + diff --git a/Space-Invaders/Header/Player/PlayerView.h b/Space-Invaders/Header/Player/PlayerView.h new file mode 100644 index 000000000..aa6741d2b --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerView.h @@ -0,0 +1,35 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Player +{ + class PlayerController; + + class PlayerView + { + private: + + const float player_sprite_width = 60.0f; + const float player_sprite_height = 60.0f; + + + PlayerController* player_controller; + UI::UIElement::ImageView* player_image; + + void createUIElements(); + void initializeImage(); + sf::String getPlayerTexturePath(); + + void destroy(); + + public: + PlayerView(); + ~PlayerView(); + + void initialize(PlayerController* controller); + void update(); + void render(); + + }; +} diff --git a/Space-Invaders/Header/Powerup/Controllers/OutscalBombController.h b/Space-Invaders/Header/Powerup/Controllers/OutscalBombController.h new file mode 100644 index 000000000..a290c9858 --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/OutscalBombController.h @@ -0,0 +1,19 @@ +#pragma once +#include"../../Header/Powerup/PowerupController.h" + +namespace Powerup +{ + namespace Controller + { + class OutscalBombController : public PowerupController + { + public: + OutscalBombController(PowerupType type); + virtual ~OutscalBombController(); + + void onCollected() override; + }; + } +} + + diff --git a/Space-Invaders/Header/Powerup/Controllers/RapidFireController.h b/Space-Invaders/Header/Powerup/Controllers/RapidFireController.h new file mode 100644 index 000000000..b33d21c78 --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/RapidFireController.h @@ -0,0 +1,17 @@ +#pragma once +#include"../../Header/Powerup/PowerupController.h" + +namespace Powerup +{ + namespace Controller + { + class RapidFireController :public PowerupController + { + public: + RapidFireController(PowerupType type); + virtual ~RapidFireController(); + + void onCollected()override; + }; + } +} diff --git a/Space-Invaders/Header/Powerup/Controllers/ShieldController.h b/Space-Invaders/Header/Powerup/Controllers/ShieldController.h new file mode 100644 index 000000000..2649c0cde --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/ShieldController.h @@ -0,0 +1,17 @@ +#pragma once +#include "../../Header/Powerup/PowerupController.h" + +namespace Powerup +{ + namespace Controller + { + class ShieldController :public PowerupController + { + public: + ShieldController(PowerupType type); + virtual ~ShieldController(); + + void onCollected()override; + }; + } +} diff --git a/Space-Invaders/Header/Powerup/Controllers/TripleLaserController.h b/Space-Invaders/Header/Powerup/Controllers/TripleLaserController.h new file mode 100644 index 000000000..126cb7f20 --- /dev/null +++ b/Space-Invaders/Header/Powerup/Controllers/TripleLaserController.h @@ -0,0 +1,18 @@ +#pragma once +#include"../../Header/Powerup/PowerupController.h" + +namespace Powerup +{ + namespace Controller + { + class TripleLaserController : public PowerupController + { + public: + TripleLaserController(PowerupType type); + virtual ~TripleLaserController(); + + void onCollected()override; + + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/Powerup/PowerupConfig.h b/Space-Invaders/Header/Powerup/PowerupConfig.h new file mode 100644 index 000000000..079692707 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupConfig.h @@ -0,0 +1,13 @@ +#pragma once +namespace Powerup +{ + enum class PowerupType + { + SHIELD, + RAPID_FIRE, + TRIPPLE_LASER, + OUTSCAL_BOMB, + }; +} + + diff --git a/Space-Invaders/Header/Powerup/PowerupController.h b/Space-Invaders/Header/Powerup/PowerupController.h new file mode 100644 index 000000000..37698a03e --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupController.h @@ -0,0 +1,34 @@ +#pragma once +#include"../../Header/Collectible/ICollectible.h" + +namespace Powerup +{ + class PowerupView; + class PowerupModel; + + enum class PowerupType; + + class PowerupController :public Collectible::ICollectible + { + protected: + PowerupView* powerup_view; + PowerupModel* powerup_model; + + void updatePowerupPosition(); + void handleOutOfBounds(); + + public: + PowerupController(PowerupType type); + virtual ~PowerupController(); + + void initialize(sf::Vector2f position)override; + void update()override; + void render()override; + + void onCollected()override; + + sf::Vector2f getCollectiblePosition()override; + PowerupType getPowerupType(); + }; +} + diff --git a/Space-Invaders/Header/Powerup/PowerupModel.h b/Space-Invaders/Header/Powerup/PowerupModel.h new file mode 100644 index 000000000..3431de028 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupModel.h @@ -0,0 +1,31 @@ +#pragma once +#include + +namespace Powerup +{ + enum class PowerupType; + + class PowerupModel + { + private: + float movement_speed = 300.f; + + sf::Vector2f powerup_position; + PowerupType powerup_type; + + public: + PowerupModel(PowerupType type); + ~PowerupModel(); + + void initialize(sf::Vector2f position); + + sf::Vector2f getPowerupPosition(); + void setPowerupPosition(sf::Vector2f position); + + PowerupType getPowerupType(); + void setPowerupType(PowerupType type); + + float getMovementSpeed(); + void setMovementSpeed(float speed); + }; +} diff --git a/Space-Invaders/Header/Powerup/PowerupService.h b/Space-Invaders/Header/Powerup/PowerupService.h new file mode 100644 index 000000000..ed0810d57 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupService.h @@ -0,0 +1,30 @@ +#pragma once +#include"../../Header/Collectible/ICollectible.h" +#include +#include"SFML/System/Vector2.hpp" + +namespace Powerup +{ + enum class PowerupType; + class PowerupController; + + class PowerupService + { + private: + std::vector powerup_list; + + PowerupController* createPowerup(PowerupType powerup_type); + void destroy(); + + public: + PowerupService(); + ~PowerupService(); + + void initialize(); + void update(); + void render(); + + PowerupController* spawnPowerup(PowerupType powerup_type, sf::Vector2f position); + void destroyPowerup(PowerupController* powerup_controller); + }; +} diff --git a/Space-Invaders/Header/Powerup/PowerupView.h b/Space-Invaders/Header/Powerup/PowerupView.h new file mode 100644 index 000000000..8fe8effc0 --- /dev/null +++ b/Space-Invaders/Header/Powerup/PowerupView.h @@ -0,0 +1,33 @@ +#pragma once +#include +#include"../../Header/UI/UIElement/ImageView.h" + +namespace Powerup +{ + class PowerupController; + enum class PowerupType; + + class PowerupView + { + private: + const float powerup_sprite_width = 30.f; + const float powerup_sprite_height = 30.f; + + PowerupController* powerup_controller; + UI::UIElement::ImageView* powerup_image; + + void createUIElements(); + void initializeImage(); + sf::String getPowerupTexturePath(); + + void destroy(); + + public: + PowerupView(); + ~PowerupView(); + + void initialize(PowerupController* controller); + void update(); + void render(); + }; +} diff --git a/Space-Invaders/Header/Projectile/IProjectile.h b/Space-Invaders/Header/Projectile/IProjectile.h new file mode 100644 index 000000000..52cf8083c --- /dev/null +++ b/Space-Invaders/Header/Projectile/IProjectile.h @@ -0,0 +1,21 @@ +#pragma once +#include +#include"../../Header/Bullet/BulletConfig.h" + +namespace Projectile +{ + enum class MovementDirection; + + class IProjectile + { + public: + virtual void initialize(sf::Vector2f position, Bullet::MovementDirection direction) = 0; + virtual void update() = 0; + virtual void render() = 0; + + virtual void updateProjectilePosition() = 0; + virtual sf::Vector2f getProjectilePosition() = 0; + + virtual ~IProjectile() {}; + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Sound/SoundService.h b/Space-Invaders/Header/Sound/SoundService.h new file mode 100644 index 000000000..281fc6ae0 --- /dev/null +++ b/Space-Invaders/Header/Sound/SoundService.h @@ -0,0 +1,29 @@ +#pragma once +#include"SFML/Audio.hpp" + +namespace Sound +{ + enum class SoundType + { + BUTTON_CLICK, + }; + + class SoundService + { + private: + const int background_music_volume = 30; + + sf::Music background_music; + sf::Sound sound_effect; + sf::SoundBuffer buffer_button_click; + + void loadBackgroundMusicFromFile(); + void loadSoundFromFile(); + + public: + void initialize(); + + void playSound(SoundType soundType); + void playBackgroundMusic(); + }; +} \ No newline at end of file diff --git a/Space-Invaders/Header/Time/TimeService.h b/Space-Invaders/Header/Time/TimeService.h new file mode 100644 index 000000000..04b3d72ad --- /dev/null +++ b/Space-Invaders/Header/Time/TimeService.h @@ -0,0 +1,25 @@ +#pragma once +#include + +namespace Time +{ + class TimeService + { + private: + std::chrono::time_pointprevious_time; + + float delta_time; + + void updateDeltaTime(); + float calculateDeltaTime(); + void updatePreviousTime(); + + public: + void initialize(); + void update(); + + float getDeltaTime(); + + }; +} + diff --git a/Space-Invaders/Header/UI/Interface/IUIController.h b/Space-Invaders/Header/UI/Interface/IUIController.h new file mode 100644 index 000000000..cd4bd7d05 --- /dev/null +++ b/Space-Invaders/Header/UI/Interface/IUIController.h @@ -0,0 +1,18 @@ +#pragma once + +namespace UI +{ + namespace Interface + { + class IUIController + { + public: + virtual void initialize() = 0; + virtual void update() = 0; + virtual void render() = 0; + virtual void show() = 0; + + virtual ~IUIController(){} + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/MainMenuUI/MainMenuUIController.h b/Space-Invaders/Header/UI/MainMenuUI/MainMenuUIController.h new file mode 100644 index 000000000..c70a70c0d --- /dev/null +++ b/Space-Invaders/Header/UI/MainMenuUI/MainMenuUIController.h @@ -0,0 +1,53 @@ +#pragma once +#include +#include"../../Header/UI/Interface/IUIController.h" +#include"../../Header/UI/UIElement/ImageView.h" +#include"../../Header/UI/UIElement/ButtonView.h" + +namespace UI +{ + namespace MainMenu + { + class MainMenuUIController : public Interface::IUIController + { + private: + + const float button_width = 400.f; + const float button_height = 140.f; + + const float play_button_y_position = 300.f; + const float instructions_button_y_position = 500.f; + const float quit_button_y_position = 700.f; + + const float background_alpha = 90.f; + + UIElement::ImageView* background_image; + + UIElement::ButtonView* play_button; + UIElement::ButtonView* instructions_button; + UIElement::ButtonView* quit_button; + + void createImage(); + void createButtons(); + void initializeBackgroundImage(); + void initializeButtons(); + void registerButtonCallback(); + + void playButtonCallback(); + void instructionsButtonCallback(); + void quitButtonCallback(); + + void destroy(); + + public: + MainMenuUIController(); + ~MainMenuUIController(); + + void initialize() override; + void update() override; + void render() override; + void show() override; + + }; + } +} diff --git a/Space-Invaders/Header/UI/UIElement/ButtonView.h b/Space-Invaders/Header/UI/UIElement/ButtonView.h new file mode 100644 index 000000000..e9b2a08fd --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/ButtonView.h @@ -0,0 +1,35 @@ +#pragma once +#include"../../Header/UI/UIElement/ImageView.h" +#include + +namespace UI +{ + namespace UIElement + { + class ButtonView : public UIElement::ImageView + { + private: + using CallbackFunction = std::function; + + CallbackFunction callback_function = nullptr; + + void printButtonClicked(); + + protected: + sf::String button_title; + + virtual void handleButtonInteraction(); + virtual bool clickedButton(sf::Sprite* button_sprite, sf::Vector2f mouse_position); + + public: + ButtonView(); + virtual ~ButtonView(); + + virtual void initialize(sf::String title, sf::String texture_path, float button_width, float button_height, sf::Vector2f position); + virtual void update() override; + virtual void render() override; + + void registerCallbackFunction(CallbackFunction button_callback); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/ImageView.h b/Space-Invaders/Header/UI/UIElement/ImageView.h new file mode 100644 index 000000000..d31332d31 --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/ImageView.h @@ -0,0 +1,31 @@ +#pragma once +#include"../../Header/UI/UIElement/UIView.h" + +namespace UI +{ + namespace UIElement + { + class ImageView : public UIView + { + protected: + sf::Texture image_texture; + sf::Sprite image_sprite; + + public: + ImageView(); + virtual ~ImageView(); + + virtual void initialize(sf::String texture_path, float image_width, float image_height, sf::Vector2f position); + virtual void update() override; + virtual void render() override; + + virtual void setTexture(sf::String texture_path); + virtual void setScale(float width, float height); + virtual void setPosition(sf::Vector2f position); + virtual void setRotation(float rotation_angle); + virtual void setOriginAtCentre(); + virtual void setImageAlpha(float alpha); + virtual void setCentreAlinged(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/TextView.h b/Space-Invaders/Header/UI/UIElement/TextView.h new file mode 100644 index 000000000..dddc376d4 --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/TextView.h @@ -0,0 +1,45 @@ +#pragma once +#include"../../Header/UI/UIElement/UIView.h" + +namespace UI +{ + namespace UIElement + { + enum class FontType + { + BUBBLE_BOBBLE, + DS_DIGIB, + }; + + class TextView : public UIView + { + private: + static const int default_font_size = 55; + + static sf::Font font_bubble_bobble; + static sf::Font font_DS_DIGIB; + + sf::Text text; + + static void loadFont(); + + void setFont(FontType font_type); + void setFontSize(int font_size); + void setTextPosition(sf::Vector2f position); + void setTextColor(sf::Color color); + + public: + TextView(); + virtual ~TextView(); + + static void initializeTextView(); + + virtual void initialize(sf::String text_value, sf::Vector2f position, FontType font_type = FontType::BUBBLE_BOBBLE, int font_size = default_font_size, sf::Color color = sf::Color::White); + virtual void update() override; + virtual void render() override; + + void setText(sf::String text_value); + void setTextCentreAligned(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIElement/UIView.h b/Space-Invaders/Header/UI/UIElement/UIView.h new file mode 100644 index 000000000..64f3850c8 --- /dev/null +++ b/Space-Invaders/Header/UI/UIElement/UIView.h @@ -0,0 +1,32 @@ +#pragma once +#include +#include"../../Header/Graphic/GraphicService.h" + +namespace UI +{ + namespace UIElement + { + enum class UIState + { + VISIBLE, + HIDDEN, + }; + + class UIView + { + protected: + sf::RenderWindow* game_window; + UIState ui_state; + + public: + UIView(); + virtual ~UIView(); + + virtual void initialize(); + virtual void update(); + virtual void render(); + virtual void show(); + virtual void hide(); + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Header/UI/UIService.h b/Space-Invaders/Header/UI/UIService.h new file mode 100644 index 000000000..58cc86ca7 --- /dev/null +++ b/Space-Invaders/Header/UI/UIService.h @@ -0,0 +1,34 @@ +#pragma once +#include "../../Header/UI/MainMenuUI/MainMenuUIController.h" +#include"../../Header/UI/Interface/IUIController.h" + +namespace UI +{ + + class UIService + { + private: + + MainMenu::MainMenuUIController* main_menu_controller; + + + + void createControllers(); + void initializeControllers(); + + Interface::IUIController* getCurrentUIController(); + + void destory(); + + + public: + UIService(); + ~UIService(); + + void initialize(); + void update(); + void render(); + void showScreen(); + + }; +} diff --git a/Space-Invaders/Source/Bullet/BulletController.cpp b/Space-Invaders/Source/Bullet/BulletController.cpp new file mode 100644 index 000000000..53c086b96 --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletController.cpp @@ -0,0 +1,93 @@ +#include"../../Header/Bullet/BulletController.h" +#include"../../Header/Bullet/BulletView.h" +#include"../../Header/Bullet/BulletModel.h" +#include"../../Header/Bullet/BulletConfig.h" +#include"../../Header/Global/ServiceLocator.h" + + +namespace Bullet +{ + using namespace Global; + + BulletController::BulletController(BulletType type) + { + bullet_view = new BulletView(); + bullet_model = new BulletModel(type); + } + + BulletController::~BulletController() + { + delete(bullet_view); + delete(bullet_model); + } + + void BulletController::initialize(sf::Vector2f position, Bullet::MovementDirection direction) + { + bullet_view->initialize(this); + bullet_model->initialize(position, direction); + } + + + void BulletController::update() + { + updateProjectilePosition(); + bullet_view->update(); + handleOutOfBounds(); + } + + void BulletController::render() + { + bullet_view->render(); + } + + void BulletController::updateProjectilePosition() + { + switch (bullet_model->getMovementDirection()) + { + case::Bullet::MovementDirection::UP: + moveUP(); + break; + + case::Bullet::MovementDirection::DOWN: + moveDown(); + break; + } + } + + void BulletController::moveUP() + { + sf::Vector2f currentPosition = bullet_model->getBulletPosition(); + currentPosition.y -= bullet_model->getMovementSpeed() * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + bullet_model->setBulletPosition(currentPosition); + } + + void BulletController::moveDown() + { + sf::Vector2f currentPosition = bullet_model->getBulletPosition(); + currentPosition.y += bullet_model->getMovementSpeed() * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + bullet_model->setBulletPosition(currentPosition); + } + + void BulletController::handleOutOfBounds() + { + sf::Vector2f bulletPosition = getProjectilePosition(); + sf::Vector2u windowSize = ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->getSize(); + + if (bulletPosition.x < 0 || bulletPosition.x > windowSize.x || + bulletPosition.y < 0 || bulletPosition.y > windowSize.y) + { + ServiceLocator::getInstance()->getBulletService()->destroyBullet(this); + } + } + + sf::Vector2f BulletController::getProjectilePosition() + { + return bullet_model->getBulletPosition(); + } + + BulletType BulletController::getBulletType() + { + return bullet_model->getBulletType(); + } + +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletModel.cpp b/Space-Invaders/Source/Bullet/BulletModel.cpp new file mode 100644 index 000000000..c30a4adc4 --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletModel.cpp @@ -0,0 +1,55 @@ +#include"../../Header/Bullet/BulletModel.h" + +namespace Bullet +{ + BulletModel::BulletModel(BulletType type) + { + bullet_type = type; + } + + BulletModel::~BulletModel() + { + + } + + void BulletModel::initialize(sf::Vector2f position, MovementDirection direction) + { + movement_direction = direction; + bullet_position = position; + } + + sf::Vector2f BulletModel::getBulletPosition() + { + return bullet_position; + } + + void BulletModel::setBulletPosition(sf::Vector2f position) + { + bullet_position = position; + } + + BulletType BulletModel::getBulletType() + { + return bullet_type; + } + + void BulletModel::setBulletType(BulletType type) + { + bullet_type = type; + } + + MovementDirection BulletModel::getMovementDirection() + { + return movement_direction; + } + + float BulletModel::getMovementSpeed() + { + return movement_speed; + } + + void BulletModel::setMovementSpeed(float speed) + { + movement_speed = speed; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletService.cpp b/Space-Invaders/Source/Bullet/BulletService.cpp new file mode 100644 index 000000000..09ae947ac --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletService.cpp @@ -0,0 +1,73 @@ +#include"../../Header/Bullet/BulletService.h" +#include"../../Header/Bullet/BulletController.h" +#include"../../Header/Bullet/BulletConfig.h" +#include"../../Header/Bullet/Controllers/FrostBulletController.h" +#include"../../Header/Bullet/Controllers/LaserBulletController.h" +#include"../../Header/Bullet/Controllers/TorpedoeController.h" + +namespace Bullet +{ + using namespace Controller; + using namespace Projectile; + + BulletService::BulletService() + { + + } + + BulletService::~BulletService() + { + destroy(); + } + + void BulletService::initialize() + { + + } + + void BulletService::update() + { + for (int i = 0;i < bullet_list.size();i++)bullet_list[i]->update(); + } + + void BulletService::render() + { + for (int i = 0;i < bullet_list.size();i++)bullet_list[i]->render(); + } + + BulletController* BulletService::createBullet(BulletType bullet_type) + { + switch (bullet_type) + { + case Bullet::BulletType::LASER_BULLET: + return new LaserBulletController(Bullet::BulletType::LASER_BULLET); + + case Bullet::BulletType::TORPEDO: + return new TorpedoController(Bullet::BulletType::TORPEDO); + + case Bullet::BulletType::FROST_BULLET: + return new FrostBulletController(Bullet::BulletType::FROST_BULLET); + + } + } + + void BulletService::destroy() + { + for (int i = 0;i < bullet_list.size();i++)delete(bullet_list[i]); + } + + BulletController* BulletService::spwanBullet(BulletType bullet_type, sf::Vector2f position, MovementDirection direction) + { + BulletController* bullet_controller = createBullet(bullet_type); + + bullet_controller->initialize(position, direction); + bullet_list.push_back(bullet_controller); + return bullet_controller; + } + + void BulletService::destroyBullet(BulletController* bullet_controller) + { + bullet_list.erase(std::remove(bullet_list.begin(), bullet_list.end(), bullet_controller), bullet_list.end()); + delete(bullet_controller); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/BulletView.cpp b/Space-Invaders/Source/Bullet/BulletView.cpp new file mode 100644 index 000000000..aeaf883db --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletView.cpp @@ -0,0 +1,70 @@ +#include"../../Header/Bullet/BulletView.h" +#include"../../Header/Bullet/BulletController.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Global/Config.h" +#include"../../Header/Bullet/BulletConfig.h" + +namespace Bullet +{ + using namespace Global; + using namespace UI::UIElement; + + BulletView::BulletView() + { + createUIElements(); + } + + BulletView::~BulletView() + { + destroy(); + } + + void BulletView::initialize(BulletController* controller) + { + bullet_controller = controller; + initializeImage(); + } + + void BulletView::createUIElements() + { + bullet_image = new ImageView(); + } + + void BulletView::initializeImage() + { + bullet_image->initialize(getBulletTexturePath(), bullet_sprite_width,bullet_sprite_height,bullet_controller->getProjectilePosition()); + } + + void BulletView::update() + { + bullet_image->setPosition(bullet_controller->getProjectilePosition()); + } + + void BulletView::render() + { + bullet_image->render(); + } + + + + sf::String BulletView::getBulletTexturePath() + { + switch (bullet_controller->getBulletType()) + { + case::Bullet::BulletType::LASER_BULLET: + return Config::laser_bullet_texture_path; + + case::Bullet::BulletType::FROST_BULLET: + return Config::frost_beam_texture_path; + + case::Bullet::BulletType::TORPEDO: + return Config::torpedoe_texture_path; + + } + } + + void BulletView::destroy() + { + delete(bullet_image); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/Controllers/FrostBulletController.cpp b/Space-Invaders/Source/Bullet/Controllers/FrostBulletController.cpp new file mode 100644 index 000000000..186a9fc72 --- /dev/null +++ b/Space-Invaders/Source/Bullet/Controllers/FrostBulletController.cpp @@ -0,0 +1,24 @@ +#include"../../Header/Bullet/Controllers/FrostBulletController.h" +#include"../../Header/Bullet/BulletModel.h" + +namespace Bullet +{ + namespace Controller + { + FrostBulletController::FrostBulletController(BulletType type) :BulletController(type) + { + + } + + FrostBulletController::~FrostBulletController() + { + + } + + void FrostBulletController::initialize(sf::Vector2f position, MovementDirection direction) + { + BulletController::initialize(position, direction); + bullet_model->setMovementSpeed(frost_bullet_movement_speed); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/Controllers/LaserBulletController.cpp b/Space-Invaders/Source/Bullet/Controllers/LaserBulletController.cpp new file mode 100644 index 000000000..b71a3d61f --- /dev/null +++ b/Space-Invaders/Source/Bullet/Controllers/LaserBulletController.cpp @@ -0,0 +1,22 @@ +#include"../../Header/Bullet/Controllers/LaserBulletController.h" + +namespace Bullet +{ + namespace Controller + { + LaserBulletController::LaserBulletController(BulletType type):BulletController(type) + { + + } + + LaserBulletController::~LaserBulletController() + { + + } + + void LaserBulletController::initialize(sf::Vector2f position, MovementDirection direction) + { + BulletController::initialize(position, direction); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Bullet/Controllers/TorpedoeController.cpp b/Space-Invaders/Source/Bullet/Controllers/TorpedoeController.cpp new file mode 100644 index 000000000..e303ab488 --- /dev/null +++ b/Space-Invaders/Source/Bullet/Controllers/TorpedoeController.cpp @@ -0,0 +1,24 @@ +#include"../../Header/Bullet/Controllers/TorpedoeController.h" +#include"../../Header/Bullet/BulletModel.h" + +namespace Bullet +{ + namespace Controller + { + TorpedoController::TorpedoController(BulletType type) :BulletController(type) + { + + } + + TorpedoController::~TorpedoController() + { + + } + + void TorpedoController::initialize(sf::Vector2f position, MovementDirection direction) + { + BulletController::initialize(position, direction); + bullet_model->setMovementSpeed(torpedo_movement_speed); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/ElementService/Bunker/BunkerController.cpp b/Space-Invaders/Source/ElementService/Bunker/BunkerController.cpp new file mode 100644 index 000000000..5536abb02 --- /dev/null +++ b/Space-Invaders/Source/ElementService/Bunker/BunkerController.cpp @@ -0,0 +1,39 @@ +#include"../../Header/Elements/Bunker/BunkerController.h" +#include"../../Header/Elements/Bunker/BunkerView.h" + +namespace Element +{ + namespace Bunker + { + BunkerController::BunkerController() + { + bunker_view = new BunkerView(); + } + + BunkerController::~BunkerController() + { + delete(bunker_view); + } + + void BunkerController::initialize(BunkerData data) + { + bunker_data = data; + bunker_view->initialize(this); + } + + void BunkerController::update() + { + bunker_view->update(); + } + + void BunkerController::render() + { + bunker_view->render(); + } + + sf::Vector2f BunkerController::getBunkerPosition() + { + return bunker_data.position; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/ElementService/Bunker/BunkerModel.cpp b/Space-Invaders/Source/ElementService/Bunker/BunkerModel.cpp new file mode 100644 index 000000000..b3a81df5b --- /dev/null +++ b/Space-Invaders/Source/ElementService/Bunker/BunkerModel.cpp @@ -0,0 +1,17 @@ +#include"../../Header/Elements/Bunker/BunkerModel.h" + +namespace Element +{ + namespace Bunker + { + BunkerData::BunkerData() + { + + }; + + BunkerData::BunkerData(sf::Vector2f position) + { + this->position = position; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/ElementService/Bunker/BunkerView.cpp b/Space-Invaders/Source/ElementService/Bunker/BunkerView.cpp new file mode 100644 index 000000000..92e832365 --- /dev/null +++ b/Space-Invaders/Source/ElementService/Bunker/BunkerView.cpp @@ -0,0 +1,61 @@ +#include"../../Header/Elements/Bunker/BunkerView.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Elements/Bunker/BunkerController.h" +#include"../../Header/Global/Config.h" + +namespace Element +{ + namespace Bunker + { + using namespace Global; + using namespace UI::UIElement; + + BunkerView::BunkerView() + { + createUIElements(); + } + + BunkerView::~BunkerView() + { + destroy(); + } + + void BunkerView::initialize(BunkerController* controller) + { + bunker_controller = controller; + initializeImage(); + } + + void BunkerView::createUIElements() + { + bunker_image = new ImageView(); + } + + void BunkerView::initializeImage() + { + bunker_image->initialize(getBunkerTexturePath(), bunker_sprite_width, bunker_sprite_height, bunker_controller->getBunkerPosition()); + } + + void BunkerView::update() + { + bunker_image->setPosition(bunker_controller->getBunkerPosition()); + bunker_image->update(); + } + + void BunkerView::render() + { + bunker_image->render(); + } + + sf::String BunkerView::getBunkerTexturePath() + { + return Config::bunker_texture_path; + } + + void BunkerView::destroy() + { + delete(bunker_image); + } + + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/ElementService/ElementService.cpp b/Space-Invaders/Source/ElementService/ElementService.cpp new file mode 100644 index 000000000..caf62f9a2 --- /dev/null +++ b/Space-Invaders/Source/ElementService/ElementService.cpp @@ -0,0 +1,40 @@ +#include"../../Header/Elements/ElementService.h" + +namespace Element +{ + ElementService::ElementService() + { + + } + + ElementService::~ElementService() + { + destroy(); + } + + void ElementService::initialize() + { + for (int i = 0;i < bunker_data_list.size();i++) + { + Bunker::BunkerController* bunker_controller = new Bunker::BunkerController(); + + bunker_controller->initialize(bunker_data_list[i]); + bunker_list.push_back(bunker_controller); + } + } + + void ElementService::update() + { + for (int i = 0;i < bunker_list.size();i++)bunker_list[i]->update(); + } + + void ElementService::render() + { + for (int i = 0 ; i < bunker_list.size(); i++)bunker_list[i]->render(); + } + + void ElementService::destroy() + { + for (int i = 0;i < bunker_list.size();i++)delete(bunker_list[i]); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/Controllers/SubZeroController.cpp b/Space-Invaders/Source/Enemy/Controllers/SubZeroController.cpp new file mode 100644 index 000000000..5b2b5426e --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/SubZeroController.cpp @@ -0,0 +1,57 @@ +#include "../../Header/Enemy/Controllers/SubZeroController.h" +#include "../../Header/Enemy/EnemyModel.h" +#include "../../header/Enemy/EnemyConfig.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletService.h" + +namespace Enemy +{ + + using namespace Global; + using namespace Bullet; + + namespace Controller + { + SubzeroController::SubzeroController(EnemyType type) :EnemyController(type) + { + + } + + SubzeroController::~SubzeroController() + { + + } + + void SubzeroController::initialize() + { + EnemyController::initialize(); + enemy_model->setMovementDirection(MovementDirection::DOWN); + rate_of_fire = subzero_rate_of_fire; + } + + void SubzeroController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spwanBullet(BulletType::FROST_BULLET, + enemy_model->getEnemyPosition() + enemy_model->barrel_position_offset, + Bullet::MovementDirection::DOWN); + } + + void SubzeroController::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::DOWN: + moveDown(); + break; + } + } + + void SubzeroController::moveDown() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + currentPosition.y += vertical_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + enemy_model->setEnemyPosition(currentPosition); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/Controllers/ThunderSnakeController.cpp b/Space-Invaders/Source/Enemy/Controllers/ThunderSnakeController.cpp new file mode 100644 index 000000000..802c3b885 --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/ThunderSnakeController.cpp @@ -0,0 +1,88 @@ +#include"../../Header/Enemy/Controllers/ThunderSnakeController.h" +#include"../../Header/Enemy/EnemyModel.h" +#include"../../Header/Enemy/EnemyConfig.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletService.h" + +namespace Enemy +{ + using namespace Global; + using namespace Bullet; + + namespace Controller + { + ThunderSnakeController::ThunderSnakeController(EnemyType type) : EnemyController(type) + { + + } + + ThunderSnakeController::~ThunderSnakeController() + { + + } + + void ThunderSnakeController::initialize() + { + EnemyController::initialize(); + rate_of_fire = thunder_snake_rate_of_fire; + } + + void ThunderSnakeController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spwanBullet(BulletType::TORPEDO, + enemy_model->getEnemyPosition() + enemy_model->barrel_position_offset, + Bullet::MovementDirection::DOWN); + } + + + void ThunderSnakeController::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::LEFT: + moveLeft(); + break; + + case::Enemy::MovementDirection::RIGHT: + moveRight(); + break; + } + } + + void ThunderSnakeController::moveLeft() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + currentPosition.y += vertical_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + currentPosition.x -= horizontal_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentPosition.x <= enemy_model->left_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::RIGHT); + } + else + { + enemy_model->setEnemyPosition(currentPosition); + } + + } + + + void ThunderSnakeController::moveRight() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + currentPosition.y += vertical_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + currentPosition.x += horizontal_movement_speed* ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentPosition.x >= enemy_model->right_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::LEFT); + } + else + { + enemy_model->setEnemyPosition(currentPosition); + } + + } + } +} + diff --git a/Space-Invaders/Source/Enemy/Controllers/UFOController.cpp b/Space-Invaders/Source/Enemy/Controllers/UFOController.cpp new file mode 100644 index 000000000..b6e8e3fc2 --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/UFOController.cpp @@ -0,0 +1,91 @@ +#include"../../Header/Enemy/Controllers/UFOController.h" +#include"../../Header/Enemy/EnemyConfig.h" +#include"../../Header/Enemy/EnemyModel.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletService.h" + +namespace Enemy +{ + using namespace Global; + using namespace Bullet; + + namespace Controller + { + UFOController::UFOController(EnemyType type) : EnemyController(type) + { + + } + + UFOController::~UFOController() + { + + } + + void UFOController::initialize() + { + EnemyController::initialize(); + enemy_model->setMovementDirection(MovementDirection::LEFT); + } + + void UFOController::fireBullet() + { + + } + + Powerup::PowerupType UFOController::getRandomPowerupType() + { + std::srand(static_cast(std::time(nullptr))); + + int random_value = std::rand() % (static_cast(Powerup::PowerupType::OUTSCAL_BOMB) + 1); + return static_cast(random_value); + } + + void UFOController::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::LEFT: + moveLeft(); + break; + + case::Enemy::MovementDirection::RIGHT: + moveRight(); + break; + } + } + + void UFOController::moveLeft() + { + sf::Vector2f currentposition = enemy_model->getEnemyPosition(); + + currentposition.x -= enemy_model->enemy_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentposition.x <= enemy_model -> left_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::RIGHT); + enemy_model->setReferencePosition(currentposition); + } + else + { + enemy_model->setEnemyPosition(currentposition); + } + } + + void UFOController::moveRight() + { + sf::Vector2f currentposition = enemy_model->getEnemyPosition(); + + currentposition.x += enemy_model->enemy_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + if (currentposition.x >= enemy_model->right_most_position.x) + { + enemy_model->setMovementDirection(MovementDirection::LEFT); + enemy_model->setReferencePosition(currentposition); + } + else + { + enemy_model->setEnemyPosition(currentposition); + } + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/Controllers/ZapperController.cpp b/Space-Invaders/Source/Enemy/Controllers/ZapperController.cpp new file mode 100644 index 000000000..6ff0960f7 --- /dev/null +++ b/Space-Invaders/Source/Enemy/Controllers/ZapperController.cpp @@ -0,0 +1,132 @@ +#include "../../Header/Enemy/Controllers/ZapperController.h" +#include "../../Header/Enemy/EnemyModel.h" +#include "../../Header/Enemy/EnemyConfig.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletService.h" + + +namespace Enemy +{ + using namespace Global; + using namespace Bullet; + + namespace Controller + { + ZapperController::ZapperController(EnemyType type) : EnemyController(type) { } + + ZapperController::~ZapperController() { } + + void ZapperController::initialize() + { + EnemyController::initialize(); + enemy_model->setMovementDirection(MovementDirection::DOWN); + rate_of_fire = zapper_rate_of_fire; + } + + void ZapperController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spwanBullet(BulletType::LASER_BULLET, + enemy_model->getEnemyPosition() + enemy_model->barrel_position_offset, + Bullet::MovementDirection::DOWN); + } + + void ZapperController::move() + { + + switch (enemy_model->getMovementDirection()) + { + + case::Enemy::MovementDirection::LEFT: + moveLeft(); + break; + + + case::Enemy::MovementDirection::RIGHT: + moveRight(); + break; + + + case::Enemy::MovementDirection::DOWN: + moveDown(); + break; + } + } + + + void ZapperController::moveLeft() + { + + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + + currentPosition.x -= enemy_model->enemy_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + + if (currentPosition.x <= enemy_model->left_most_position.x) + { + + enemy_model->setMovementDirection(MovementDirection::DOWN); + enemy_model->setReferencePosition(currentPosition); + } + else + { + + enemy_model->setEnemyPosition(currentPosition); + } + } + + + void ZapperController::moveRight() + { + + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + + currentPosition.x += enemy_model->enemy_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + + if (currentPosition.x >= enemy_model->right_most_position.x) + { + + enemy_model->setMovementDirection(MovementDirection::DOWN); + enemy_model->setReferencePosition(currentPosition); + } + else + { + + enemy_model->setEnemyPosition(currentPosition); + } + } + + + void ZapperController::moveDown() + { + + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + + + currentPosition.y += enemy_model->enemy_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + + if (currentPosition.y >= enemy_model->getReferencePosition().y + vertical_travel_distance) + { + + if (enemy_model->getReferencePosition().x <= enemy_model->left_most_position.x) + { + + enemy_model->setMovementDirection(MovementDirection::RIGHT); + } + else + { + + enemy_model->setMovementDirection(MovementDirection::LEFT); + } + } + else + { + + enemy_model->setEnemyPosition(currentPosition); + } + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyController.cpp b/Space-Invaders/Source/Enemy/EnemyController.cpp new file mode 100644 index 000000000..6cbfbc722 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyController.cpp @@ -0,0 +1,100 @@ +#include "../../Header/Enemy/EnemyController.h" +#include "../../Header/Enemy/EnemyView.h" +#include "../../Header/Enemy/EnemyModel.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Enemy/Controllers/SubZeroController.h" +#include"../../Header/Enemy/Controllers/ZapperController.h" +#include"../../Header/Enemy/Controllers/ThunderSnakeController.h" +#include"../../Header/Bullet/BulletConfig.h" + +namespace Enemy +{ + using namespace Global; + using namespace Time; + using namespace Bullet; + + EnemyController::EnemyController(EnemyType type) + { + enemy_view = new EnemyView(); + enemy_model = new EnemyModel(type); + } + + EnemyController::~EnemyController() + { + delete (enemy_view); + delete (enemy_model); + } + + void EnemyController::initialize() + { + enemy_model->initialize(); + enemy_model->setEnemyPosition(getRandomInitialPosition()); + enemy_view->initialize(this); + } + + void EnemyController::update() + { + move(); + updateFireTimer(); + processBulletFire(); + enemy_view->update(); + handleOutOfBounds(); + } + + void EnemyController::render() + { + enemy_view->render(); + } + + void EnemyController::updateFireTimer() + { + elapsed_fire_duration += ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + } + + void EnemyController::processBulletFire() + { + if (elapsed_fire_duration >= rate_of_fire) + { + fireBullet(); + elapsed_fire_duration = 0.f; + } + } + + sf::Vector2f EnemyController::getRandomInitialPosition() + { + float x_offset_distance = (std::rand() % static_cast(enemy_model->right_most_position.x - enemy_model->left_most_position.x)); + + float x_position = enemy_model->left_most_position.x + x_offset_distance; + + float y_position = enemy_model->left_most_position.y; + + return sf::Vector2f(x_position, y_position); + } + + void EnemyController::handleOutOfBounds() + { + sf::Vector2f enemyPosition = getEnemyPosition(); + sf::Vector2u windowSize = ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->getSize(); + + if (enemyPosition.x<0 || enemyPosition.x>windowSize.x || + enemyPosition.y<0 || enemyPosition.y>windowSize.y) + { + ServiceLocator::getInstance()->getEnemyService()->destroyEnemy(this); + } + } + + sf::Vector2f EnemyController::getEnemyPosition() + { + return enemy_model->getEnemyPosition(); + } + + EnemyState EnemyController::getEnemyState() + { + return enemy_model->getEnemyState(); + } + + EnemyType EnemyController::getEnemyType() + { + return enemy_model->getEnemyType(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyModel.cpp b/Space-Invaders/Source/Enemy/EnemyModel.cpp new file mode 100644 index 000000000..0d5d8b7d1 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyModel.cpp @@ -0,0 +1,71 @@ +#include "../../Header/Enemy/EnemyModel.h" +#include "../../Header/Enemy/EnemyConfig.h" + +namespace Enemy +{ + EnemyModel::EnemyModel(EnemyType type) { + + enemy_type = type; + + } + + EnemyModel::~EnemyModel() { } + + void EnemyModel::initialize() + { + enemy_state = EnemyState::PATROLLING; + movement_direction = MovementDirection::RIGHT; + enemy_position = reference_position; + } + + sf::Vector2f EnemyModel::getEnemyPosition() + { + return enemy_position; + } + + void EnemyModel::setEnemyPosition(sf::Vector2f position) + { + enemy_position = position; + } + + sf::Vector2f EnemyModel::getReferencePosition() + { + return reference_position; + } + + void EnemyModel::setReferencePosition(sf::Vector2f position) + { + reference_position = position; + } + + EnemyState EnemyModel::getEnemyState() + { + return enemy_state; + } + + void EnemyModel::setEnemyState(EnemyState state) + { + enemy_state = state; + } + + EnemyType EnemyModel::getEnemyType() + { + return enemy_type; + } + + void EnemyModel::setEnemyType(EnemyType type) + { + enemy_type = type; + } + + + MovementDirection EnemyModel::getMovementDirection() + { + return movement_direction; + } + + void EnemyModel::setMovementDirection(MovementDirection direction) + { + movement_direction = direction; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyService.cpp b/Space-Invaders/Source/Enemy/EnemyService.cpp new file mode 100644 index 000000000..45c5d91bd --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyService.cpp @@ -0,0 +1,99 @@ +#include "../../Header/Enemy/EnemyService.h" +#include "../../Header/Enemy/EnemyController.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Time/TimeService.h" +#include "../../Header/Enemy/EnemyConfig.h" +#include "../../Header/Enemy/Controllers/SubZeroController.h" +#include"../../Header/Enemy/Controllers/ZapperController.h" +#include"../../Header/Enemy/Controllers/ThunderSnakeController.h" +#include"../../Header/Enemy/Controllers/UFOController.h" + +namespace Enemy +{ + using namespace Global; + using namespace Time; + using namespace Controller; + + EnemyService::EnemyService() + { + std::srand(static_cast(std::time(nullptr))); + } + + EnemyService::~EnemyService() + { + + } + + void EnemyService::initialize() + { + spawn_timer = spawn_interval; + } + + void EnemyService::update() + { + updateSpawnTimer(); + processEnemySpawn(); + + for (int i = 0; i < enemy_list.size(); i++) enemy_list[i]->update(); + } + + void EnemyService::render() + { + for (int i = 0; i < enemy_list.size(); i++) enemy_list[i]->render(); + } + + void EnemyService::updateSpawnTimer() + { + spawn_timer += ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + } + + void EnemyService::processEnemySpawn() + { + if (spawn_timer >= spawn_interval) + { + spawnEnemy(); + spawn_timer = 0.0f; + } + } + + EnemyType EnemyService::getRandomEnemyType() + { + int randomType = std::rand() % 4; + return static_cast(randomType); + } + + EnemyController* EnemyService::spawnEnemy() + { + EnemyController* enemy_controller = createEnemy(getRandomEnemyType()); + + enemy_controller->initialize(); + + enemy_list.push_back(enemy_controller); + return enemy_controller; + } + + EnemyController* EnemyService::createEnemy(EnemyType enemy_type) + { + switch (enemy_type) + { + case::Enemy::EnemyType::ZAPPER: + return new ZapperController(Enemy::EnemyType::ZAPPER); + + case::Enemy::EnemyType::SUBZERO: + return new SubzeroController(Enemy::EnemyType::SUBZERO); + + case::Enemy::EnemyType::THUNDER_SNAKE: + return new ThunderSnakeController(Enemy::EnemyType::THUNDER_SNAKE); + + case::Enemy::EnemyType::UFO: + return new UFOController(Enemy::EnemyType::UFO); + } + } + + void EnemyService::destroyEnemy(EnemyController* enemy_controller) + { + enemy_list.erase(std::remove(enemy_list.begin(), enemy_list.end(), enemy_controller), enemy_list.end()); + delete(enemy_controller); + } + +} \ No newline at end of file diff --git a/Space-Invaders/Source/Enemy/EnemyView.cpp b/Space-Invaders/Source/Enemy/EnemyView.cpp new file mode 100644 index 000000000..a39db33af --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyView.cpp @@ -0,0 +1,75 @@ +#include "../../Header/Enemy/EnemyView.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Graphic/GraphicService.h" +#include "../../Header/Enemy/EnemyController.h" +#include"../../Header/Enemy/EnemyConfig.h" +#include"../../Header/Global/Config.h" + +namespace Enemy +{ + using namespace Global; + using namespace Graphic; + using namespace UI::UIElement; + + + EnemyView::EnemyView() + { + createUIElements(); + } + + EnemyView::~EnemyView() + { + destroy(); + } + + void EnemyView::initialize(EnemyController* controller) + { + enemy_controller = controller; + initializeImage(); + } + + void EnemyView::createUIElements() + { + enemy_image = new ImageView(); + } + + void EnemyView::initializeImage() + { + enemy_image->initialize(getEnemyTexturePath(), enemy_sprite_width, enemy_sprite_height, enemy_controller->getEnemyPosition()); + } + + void EnemyView::update() + { + enemy_image->setPosition(enemy_controller->getEnemyPosition()); + enemy_image->update(); + } + + void EnemyView::render() + { + enemy_image->render(); + } + + sf::String EnemyView::getEnemyTexturePath() + { + switch (enemy_controller->getEnemyType()) + { + case::Enemy::EnemyType::SUBZERO: + return Config::subzero_texture_path; + + case::Enemy::EnemyType::ZAPPER: + return Config::zapper_texture_path; + + case::Enemy::EnemyType::THUNDER_SNAKE: + return Config::thunder_snake_texture_path; + + case::Enemy::EnemyType::UFO: + return Config::ufo_texture_path; + } + } + + void EnemyView::destroy() + { + delete(enemy_image); + } + +} diff --git a/Space-Invaders/Source/Event/EventService.cpp b/Space-Invaders/Source/Event/EventService.cpp new file mode 100644 index 000000000..8270c6bf6 --- /dev/null +++ b/Space-Invaders/Source/Event/EventService.cpp @@ -0,0 +1,139 @@ +#include "../../Header/Event/EventService.h" +#include "../../Header/Main/GameService.h" +#include "../../Header/Graphic/GraphicService.h" +#include "../../Header/Global/ServiceLocator.h" + +namespace Event +{ + using namespace Global; + EventService::EventService() + { + game_window = nullptr; + } + + EventService::~EventService() = default; + + void EventService::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + + } + + void EventService::update() + { + updateMouseButtonState(left_mouse_button_state, sf::Mouse::Left); + updateMouseButtonState(right_mouse_button_state, sf::Mouse::Right); + updateKeyboardButtonState(left_arrow_button_state, sf::Keyboard::Left); + updateKeyboardButtonState(right_arrow_button_state, sf::Keyboard::Right); + updateKeyboardButtonState(A_button_state, sf::Keyboard::A); + updateKeyboardButtonState(D_button_state, sf::Keyboard::D); + } + + void EventService::processEvents() + { + if (isGameWindowOpen()) + { + while (game_window->pollEvent(game_event)) + { + if (gameWindowWasClosed() || hasQuitGame()) + { + game_window->close(); + } + } + } + } + + void EventService::updateMouseButtonState(ButtonState& current_button_state, sf::Mouse::Button mouse_button) + { + if (sf::Mouse::isButtonPressed(mouse_button)) + { + switch (current_button_state) + { + case ButtonState::RELEASED: + current_button_state = ButtonState::PRESSED; + break; + case ButtonState::PRESSED: + current_button_state = ButtonState::HELD; + break; + } + } + else + { + current_button_state = ButtonState::RELEASED; + } + } + + void EventService::updateKeyboardButtonState(ButtonState& current_button_state, sf::Keyboard::Key keyboard_button) + { + if (sf::Keyboard::isKeyPressed(keyboard_button)) + { + switch (current_button_state) + { + case ButtonState::RELEASED: + current_button_state = ButtonState::PRESSED; + break; + case ButtonState::PRESSED: + current_button_state = ButtonState::HELD; + break; + } + } + else + { + current_button_state = ButtonState::RELEASED; + } + } + + bool EventService::hasQuitGame() + { + return(isKeyboardEvent() && pressedEscapeKey()); + } + + bool EventService::isKeyboardEvent() + { + return game_event.type == sf::Event::KeyPressed; + } + + bool EventService::pressedEscapeKey() + { + return game_event.key.code == sf::Keyboard::Escape; + } + + bool EventService::isGameWindowOpen() + { + return game_window != nullptr; + } + + bool EventService::gameWindowWasClosed() + { + return game_event.type == sf::Event::Closed; + } + + bool EventService::pressedLeftKey() + { + return left_arrow_button_state == ButtonState::HELD; + } + + bool EventService::pressedRightKey() + { + return right_arrow_button_state == ButtonState::HELD; + } + + bool EventService::pressedAKey() + { + return A_button_state == ButtonState::HELD; + } + + bool EventService::pressedDKey() + { + return D_button_state == ButtonState::HELD; + } + + bool EventService::pressedLeftMouseButton() + { + return left_mouse_button_state == ButtonState::PRESSED; + } + + bool EventService::pressedRightMouseButton() + { return right_mouse_button_state == ButtonState::PRESSED; + } +} diff --git a/Space-Invaders/Source/Gameplay/GameplayController.cpp b/Space-Invaders/Source/Gameplay/GameplayController.cpp new file mode 100644 index 000000000..e8a642bac --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayController.cpp @@ -0,0 +1,30 @@ +#include"../../Header/Gameplay/GameplayController.h" +#include"../../Header/Gameplay/GameplayView.h" + +namespace Gameplay +{ + GameplayController::GameplayController() + { + gameplay_view = new GameplayView(); + } + + GameplayController::~GameplayController() + { + delete(gameplay_view); + } + + void GameplayController::initialize() + { + gameplay_view->initialize(); + } + + void GameplayController::update() + { + gameplay_view->update(); + } + + void GameplayController::render() + { + gameplay_view->render(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Gameplay/GameplayService.cpp b/Space-Invaders/Source/Gameplay/GameplayService.cpp new file mode 100644 index 000000000..3793d3975 --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayService.cpp @@ -0,0 +1,30 @@ +#include"../../Header/Gameplay/GameplayService.h" +#include"../../Header/Gameplay/GameplayController.h" + +namespace Gameplay +{ + GameplayService::GameplayService() + { + gameplay_controller = new GameplayController(); + } + + GameplayService::~GameplayService() + { + delete(gameplay_controller); + } + + void GameplayService::initialize() + { + gameplay_controller->initialize(); + } + + void GameplayService::update() + { + gameplay_controller->update(); + } + + void GameplayService::render() + { + gameplay_controller->render(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Gameplay/GameplayView.cpp b/Space-Invaders/Source/Gameplay/GameplayView.cpp new file mode 100644 index 000000000..e6858381e --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayView.cpp @@ -0,0 +1,56 @@ +#include"../../Header/Gameplay/GameplayView.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Graphic/GraphicService.h" +#include"../../Header/Global/Config.h" + +namespace Gameplay +{ + using namespace Global; + using namespace Graphic; + using namespace UI::UIElement; + + GameplayView::GameplayView() + { + createUIElements(); + } + + GameplayView::~GameplayView() + { + destroy(); + } + + void GameplayView::createUIElements() + { + background_image = new ImageView(); + } + + void GameplayView::initialize() + { + initializeImage(); + } + + void GameplayView::initializeImage() + { + background_image->initialize(getBackgroundTexturePath(), background_sprite_width, background_sprite_height, sf::Vector2f(0, 0)); + } + + void GameplayView::update() + { + + } + + void GameplayView::render() + { + background_image->render(); + } + + sf::String GameplayView::getBackgroundTexturePath() + { + return Config::background_texture_path; + } + + void GameplayView::destroy() + { + delete(background_image); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Global/Config.cpp b/Space-Invaders/Source/Global/Config.cpp new file mode 100644 index 000000000..901495b03 --- /dev/null +++ b/Space-Invaders/Source/Global/Config.cpp @@ -0,0 +1,56 @@ +#include "../../header/Global/Config.h" + +namespace Global +{ + const sf::String Config::outscal_logo_texture_path = "assets/textures/outscal_logo.png"; + + const sf::String Config::background_texture_path = "assets/textures/space_invaders_bg.png"; + + const sf::String Config::player_texture_path = "assets/textures/player_ship.png"; + + + const sf::String Config::zapper_texture_path = "assets/textures/zapper.png"; + + const sf::String Config::thunder_snake_texture_path = "assets/textures/thunder_snake.png"; + + const sf::String Config::subzero_texture_path = "assets/textures/subzero.png"; + + const sf::String Config::ufo_texture_path = "assets/textures/ufo.png"; + + const sf::String Config::bunker_texture_path = "assets/textures/bunker.png"; + + + const sf::String Config::shield_texture_path = "assets/textures/shield.png"; + + const sf::String Config::tripple_laser_texture_path = "assets/textures/tripple_laser.png"; + + const sf::String Config::rapid_fire_texture_path = "assets/textures/rapid_fire.png"; + + const sf::String Config::outscal_bomb_texture_path = "assets/textures/outscal_bomb.png"; + + + const sf::String Config::laser_bullet_texture_path = "assets/textures/laser_bullet.png"; + + const sf::String Config::torpedoe_texture_path = "assets/textures/torpedoe.png"; + + const sf::String Config::frost_beam_texture_path = "assets/textures/frost_beam.png"; + + + const sf::String Config::play_button_texture_path = "assets/textures/play_button.png"; + + const sf::String Config::instructions_button_texture_path = "assets/textures/instructions_button.png"; + + const sf::String Config::quit_button_texture_path = "assets/textures/quit_button.png"; + + const sf::String Config::menu_button_texture_path = "assets/textures/menu_button.png"; + + + const sf::String Config::bubble_bobble_font_path = "assets/fonts/bubbleBobble.ttf"; + + const sf::String Config::DS_DIGIB_font_path = "assets/fonts/DS_DIGIB.ttf"; + + + const sf::String Config::background_music_path = "assets/sounds/background_music.mp3"; + + const sf::String Config::button_click_sound_path = "assets/sounds/button_click_sound.wav"; +} diff --git a/Space-Invaders/Source/Global/ServiceLocator.cpp b/Space-Invaders/Source/Global/ServiceLocator.cpp new file mode 100644 index 000000000..b3b3d48bb --- /dev/null +++ b/Space-Invaders/Source/Global/ServiceLocator.cpp @@ -0,0 +1,182 @@ +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/Main/GameService.h" + +namespace Global +{ + using namespace Graphic; + using namespace Event; + using namespace Time; + using namespace Player; + using namespace UI; + using namespace Enemy; + using namespace Main; + using namespace Gameplay; + using namespace Element; + using namespace Sound; + using namespace Bullet; + using namespace Powerup; + + ServiceLocator::ServiceLocator() + { + graphic_service = nullptr; + event_service = nullptr; + player_service = nullptr; + time_service = nullptr; + ui_service = nullptr; + enemy_service = nullptr; + gameplay_service = nullptr; + element_service = nullptr; + sound_service = nullptr; + bullet_service = nullptr; + powerup_service = nullptr; + createServices(); + } + + ServiceLocator::~ServiceLocator() + { + clearAllServices(); + } + + void ServiceLocator::createServices() + { + graphic_service = new GraphicService(); + event_service = new EventService(); + player_service = new PlayerService(); + time_service = new TimeService(); + ui_service = new UIService(); + enemy_service = new EnemyService(); + gameplay_service = new GameplayService(); + element_service = new ElementService(); + bullet_service = new BulletService(); + sound_service = new SoundService(); + powerup_service = new PowerupService(); + } + + void ServiceLocator::clearAllServices() + { + delete(graphic_service); + delete(event_service); + delete(player_service); + delete(time_service); + delete(ui_service); + delete(enemy_service); + delete(gameplay_service); + delete(element_service); + delete(bullet_service); + delete(sound_service); + delete(powerup_service); + graphic_service = nullptr; + } + + ServiceLocator* ServiceLocator::getInstance() + { + static ServiceLocator instance; + return &instance; + } + + void ServiceLocator::initialize() + { + graphic_service->initialize(); + event_service->initialize(); + player_service->initialize(); + time_service->initialize(); + ui_service->initialize(); + enemy_service->initialize(); + gameplay_service->initialize(); + element_service->initialize(); + sound_service->initialize(); + powerup_service->initialize(); + } + + void ServiceLocator::update() + { + graphic_service->update(); + time_service->update(); + event_service->update(); + + if (GameService::getGameState() == GameState::GAMEPLAY) + { + gameplay_service->update(); + player_service->update(); + enemy_service->update(); + bullet_service->update(); + element_service->update(); + powerup_service->update(); + } + ui_service->update(); + } + + + + void ServiceLocator::render() + { + graphic_service->render(); + if (GameService::getGameState() == GameState::GAMEPLAY) + { + gameplay_service->render(); + player_service->render(); + enemy_service->render(); + bullet_service->render(); + element_service->render(); + powerup_service->render(); + + } + + ui_service->render(); + } + + GraphicService* ServiceLocator::getGraphicService() + { + return graphic_service; + } + + EventService* ServiceLocator::getEventService() + { + return event_service; + } + + PlayerService* ServiceLocator::getPlayerService() + { + return player_service; + } + + TimeService* ServiceLocator::getTimeService() + { + return time_service; + } + + UIService* ServiceLocator::getUIService() + { + return ui_service; + } + + EnemyService* ServiceLocator::getEnemyService() + { + return enemy_service; + } + + GameplayService* ServiceLocator::getGameplayService() + { + return gameplay_service; + } + + ElementService* ServiceLocator::getElementService() + { + return element_service; + } + + SoundService* ServiceLocator::getSoundService() + { + return sound_service; + } + + BulletService* ServiceLocator::getBulletService() + { + return bullet_service; + } + + PowerupService* ServiceLocator::getPowerupService() + { + return powerup_service; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Graphic/GraphicService.cpp b/Space-Invaders/Source/Graphic/GraphicService.cpp new file mode 100644 index 000000000..a567cfd16 --- /dev/null +++ b/Space-Invaders/Source/Graphic/GraphicService.cpp @@ -0,0 +1,66 @@ +#include "../../Header/Graphic/GraphicService.h" + +namespace Graphic +{ + + GraphicService::GraphicService() + { + game_window = nullptr; + video_mode = nullptr; + } + + + GraphicService::~GraphicService() + { + onDestroy(); + } + + void GraphicService::initialize() + { + game_window = createGameWindow(); + game_window->setFramerateLimit(frame_rate); + } + + sf::RenderWindow* GraphicService::createGameWindow() + { + setVideoMode(); + return new sf::RenderWindow(*video_mode, game_window_title, sf::Style::Fullscreen); + + } + + void GraphicService::setVideoMode() + { + video_mode = new sf::VideoMode(game_window_width, game_window_height, sf::VideoMode::getDesktopMode().bitsPerPixel); + } + + void GraphicService::onDestroy() + { + delete(video_mode); + delete(game_window); + } + + void GraphicService::update() + { + + } + + void GraphicService::render() + { + + } + + bool GraphicService::isGameWindowOpen() + { + return game_window->isOpen(); //returns the open status of the game window + } + + sf::RenderWindow* GraphicService::getGameWindow() + { + return game_window; + } + + sf::Color GraphicService::getWindowColor() + { + return window_color; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Main/GameService.cpp b/Space-Invaders/Source/Main/GameService.cpp new file mode 100644 index 000000000..a442230a1 --- /dev/null +++ b/Space-Invaders/Source/Main/GameService.cpp @@ -0,0 +1,79 @@ +#include "../../Header/Main/Gameservice.h" +#include "../../Header/Graphic/GraphicService.h" +#include "../../Header/Event/EventService.h" +#include "../../Header/Global/ServiceLocator.h" +#include "../../Header/UI/UIService.h" + +namespace Main +{ + using namespace Global; + + GameState GameService::current_state = GameState::BOOT; + + GameService::GameService() + { + service_locator = nullptr; + game_window = nullptr; + } + + GameService::~GameService() + { + destroy(); + } + + void GameService::ignite() + { + service_locator = ServiceLocator::getInstance(); + initialize(); + } + void GameService::showMainMenu() + { + setGameState(GameState::MAIN_MENU); + } + + void GameService::initialize() + { + service_locator->initialize(); + initializeVariables(); + showMainMenu(); + } + + void GameService::initializeVariables() + { + game_window = service_locator->getGraphicService()->getGameWindow(); + } + + void GameService::destroy() + { + //cleanup resources + } + + void GameService::update() + { + service_locator->getEventService()->processEvents(); + service_locator->update(); + } + + void GameService::render() + { + game_window->clear(service_locator->getGraphicService()->getWindowColor()); + service_locator->render(); + game_window->display(); + } + + bool GameService::isRunning() + { + // Checks if the game is currently running. + return service_locator->getGraphicService()->isGameWindowOpen(); + } + + void GameService::setGameState(GameState new_state) + { + current_state = new_state; + } + + GameState GameService::getGameState() + { + return current_state; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Player/PlayerController.cpp b/Space-Invaders/Source/Player/PlayerController.cpp new file mode 100644 index 000000000..29aaecfe1 --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerController.cpp @@ -0,0 +1,89 @@ +#include "../../Header/Player/PlayerController.h" +#include "../../Header/Player/PlayerModel.h" +#include "../../Header/Player/PlayerView.h" +#include "../../Header/Event/EventService.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Bullet/BulletService.h" +#include + +namespace Player +{ + using namespace Global; + using namespace Event; + using namespace Bullet; + + PlayerController::PlayerController() + { + player_view = new PlayerView(); + player_model = new PlayerModel(); + } + + PlayerController::~PlayerController() + { + delete(player_view); + delete(player_model); + } + void PlayerController::initialize() + { + player_model->initialize(); + player_view->initialize(this); + } + + void PlayerController::update() + { + processPlayerInput(); + player_view->update(); + } + + void PlayerController::render() + { + player_view->render(); + } + + sf::Vector2f PlayerController::getPlayerPosition() + { + return player_model->getPlayerPosition(); + } + + void PlayerController::processPlayerInput() + { + EventService* event_service = ServiceLocator::getInstance()->getEventService(); + + if (event_service->pressedLeftKey() || event_service->pressedAKey()) + { + moveLeft(); + } + + if (event_service->pressedRightKey() || event_service->pressedDKey()) + { + moveRight(); + } + + if (event_service->pressedLeftMouseButton()) fireBullet(); + } + + void PlayerController::fireBullet() + { + ServiceLocator::getInstance()->getBulletService()->spwanBullet(BulletType::LASER_BULLET, + player_model->getPlayerPosition() + player_model->barrel_position_offset, + Bullet::MovementDirection::UP); + } + + void PlayerController::moveLeft() + { + sf::Vector2f currentPosition = player_model->getPlayerPosition(); + currentPosition.x -= player_model->player_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + currentPosition.x = std::max(currentPosition.x, player_model->left_most_position.x); + player_model->setPlayerPosition(currentPosition); + } + + void PlayerController::moveRight() + { + sf::Vector2f currentPosition = player_model->getPlayerPosition(); + currentPosition.x += player_model->player_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + currentPosition.x = std::min(currentPosition.x, player_model->right_most_position.x); + player_model->setPlayerPosition(currentPosition); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Player/PlayerModel.cpp b/Space-Invaders/Source/Player/PlayerModel.cpp new file mode 100644 index 000000000..6438d2d7c --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerModel.cpp @@ -0,0 +1,51 @@ +#include "../../header/Player/PlayerModel.h" + +namespace Player +{ + PlayerModel::PlayerModel() + { + + } + + PlayerModel::~PlayerModel() + { + + } + + void PlayerModel::initialize() + { + reset(); + } + + void PlayerModel::reset() + { + player_state = PlayerState::ALIVE; + player_position = initial_player_position; + player_score = 0; + } + + sf::Vector2f PlayerModel::getPlayerPosition() + { + return player_position; + } + + void PlayerModel::setPlayerPosition(sf::Vector2f position) + { + player_position = position; + } + + int PlayerModel::getPlayeScore() + { + return player_score; + } + + void PlayerModel::setPlayerScore(int score) + { + player_score = score; + } + + void PlayerModel::setPlayerState(PlayerState state) + { + player_state = state; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Player/PlayerService.cpp b/Space-Invaders/Source/Player/PlayerService.cpp new file mode 100644 index 000000000..3a20b71f1 --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerService.cpp @@ -0,0 +1,30 @@ +#include "../../Header/Player/PlayerService.h" +#include "../../Header/Player/PlayerController.h" + +namespace Player +{ + PlayerService::PlayerService() + { + player_controller = new PlayerController(); + } + + PlayerService::~PlayerService() + { + delete(player_controller); + } + + void PlayerService::initialize() + { + player_controller->initialize(); + } + + void PlayerService::update() + { + player_controller->update(); + } + + void PlayerService::render() + { + player_controller->render(); + } +} diff --git a/Space-Invaders/Source/Player/PlayerView.cpp b/Space-Invaders/Source/Player/PlayerView.cpp new file mode 100644 index 000000000..92e497280 --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerView.cpp @@ -0,0 +1,57 @@ +#include "../../Header/Player/PlayerView.h" +#include"../../Header/Player/PlayerController.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Global/Config.h" + +namespace Player +{ + using namespace Global; + using namespace UI::UIElement; + + PlayerView::PlayerView() + { + createUIElements(); + } + + PlayerView::~PlayerView() + { + destroy(); + } + + void PlayerView::initialize(PlayerController* controller) + { + player_controller = controller; + initializeImage(); + } + + void PlayerView::createUIElements() + { + player_image = new ImageView(); + } + + void PlayerView::initializeImage() + { + player_image->initialize(getPlayerTexturePath(), player_sprite_width, player_sprite_height, player_controller->getPlayerPosition()); + } + + void PlayerView::update() + { + player_image->setPosition(player_controller->getPlayerPosition()); + player_image->update(); + } + + void PlayerView::render() + { + player_image->render(); + } + + sf::String PlayerView::getPlayerTexturePath() + { + return Config::player_texture_path; + } + + void PlayerView::destroy() + { + delete(player_image); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/Controllers/OutscaleBombController.cpp b/Space-Invaders/Source/Powerup/Controllers/OutscaleBombController.cpp new file mode 100644 index 000000000..787dad643 --- /dev/null +++ b/Space-Invaders/Source/Powerup/Controllers/OutscaleBombController.cpp @@ -0,0 +1,22 @@ +#include"../../Header/Powerup/Controllers/OutscalBombController.h" + +namespace Powerup +{ + namespace Controller + { + OutscalBombController::OutscalBombController(PowerupType type) :PowerupController(type) + { + + } + + OutscalBombController::~OutscalBombController() + { + + } + + void OutscalBombController::onCollected() + { + + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/Controllers/RapidFireController.cpp b/Space-Invaders/Source/Powerup/Controllers/RapidFireController.cpp new file mode 100644 index 000000000..82cf01a1a --- /dev/null +++ b/Space-Invaders/Source/Powerup/Controllers/RapidFireController.cpp @@ -0,0 +1,22 @@ +#include"../../Header/Powerup/Controllers/RapidFireController.h" + +namespace Powerup +{ + namespace Controller + { + RapidFireController::RapidFireController(PowerupType type) :PowerupController(type) + { + + } + + RapidFireController::~RapidFireController() + { + + } + + void RapidFireController::onCollected() + { + + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/Controllers/ShieldController.cpp b/Space-Invaders/Source/Powerup/Controllers/ShieldController.cpp new file mode 100644 index 000000000..c1e4ba946 --- /dev/null +++ b/Space-Invaders/Source/Powerup/Controllers/ShieldController.cpp @@ -0,0 +1,22 @@ +#include"../../Header/Powerup/Controllers/ShieldController.h" + +namespace Powerup +{ + namespace Controller + { + ShieldController::ShieldController(PowerupType type) :PowerupController(type) + { + + } + + ShieldController::~ShieldController() + { + + } + + void ShieldController::onCollected() + { + + }; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/Controllers/TripleLaserController.cpp b/Space-Invaders/Source/Powerup/Controllers/TripleLaserController.cpp new file mode 100644 index 000000000..d0a390945 --- /dev/null +++ b/Space-Invaders/Source/Powerup/Controllers/TripleLaserController.cpp @@ -0,0 +1,22 @@ +#include"../../Header/Powerup/Controllers/TripleLaserController.h" + +namespace Powerup +{ + namespace Controller + { + TripleLaserController::TripleLaserController(PowerupType type) :PowerupController(type) + { + + } + + TripleLaserController::~TripleLaserController() + { + + } + + void TripleLaserController::onCollected() + { + + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupController.cpp b/Space-Invaders/Source/Powerup/PowerupController.cpp new file mode 100644 index 000000000..7c35cbe2c --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupController.cpp @@ -0,0 +1,73 @@ +#include"../../Header/Powerup/PowerupController.h" +#include"../../Header/Powerup/PowerupView.h" +#include"../../Header/Powerup/PowerupModel.h" +#include"../../Header/Global/ServiceLocator.h" + +namespace Powerup +{ + using namespace Global; + + PowerupController::PowerupController(PowerupType type) + { + powerup_view = new PowerupView(); + powerup_model = new PowerupModel(type); + } + + PowerupController::~PowerupController() + { + delete(powerup_view); + delete(powerup_model); + } + + void PowerupController::initialize(sf::Vector2f position) + { + powerup_model->initialize(position); + powerup_view->initialize(this); + } + + void PowerupController::update() + { + updatePowerupPosition(); + powerup_view->update(); + } + + void PowerupController::render() + { + powerup_view->render(); + } + + void PowerupController::onCollected() + { + + } + + void PowerupController::updatePowerupPosition() + { + sf::Vector2f currentPosition = powerup_model->getPowerupPosition(); + currentPosition.y += powerup_model->getMovementSpeed() * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + powerup_model->setPowerupPosition(currentPosition); + } + + void PowerupController::handleOutOfBounds() + { + sf::Vector2f powerupPosition = getCollectiblePosition(); + sf::Vector2u windowSize = ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->getSize(); + + if (powerupPosition.x < 0 || powerupPosition.x > windowSize.x || + powerupPosition.y < 0 || powerupPosition.y > windowSize.y) + { + ServiceLocator::getInstance()->getPowerupService()->destroyPowerup(this); + } + } + + sf::Vector2f PowerupController::getCollectiblePosition() + { + return powerup_model->getPowerupPosition(); + } + + PowerupType PowerupController::getPowerupType() + { + return powerup_model->getPowerupType(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupModel.cpp b/Space-Invaders/Source/Powerup/PowerupModel.cpp new file mode 100644 index 000000000..6fd5da899 --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupModel.cpp @@ -0,0 +1,50 @@ +#include"../../Header/Powerup/PowerupModel.h" + +namespace Powerup +{ + + PowerupModel::PowerupModel(PowerupType type) + { + powerup_type = type; + } + + PowerupModel::~PowerupModel() + { + + } + + void PowerupModel::initialize(sf::Vector2f position) + { + powerup_position = position; + } + + sf::Vector2f PowerupModel::getPowerupPosition() + { + return powerup_position; + } + + void PowerupModel::setPowerupPosition(sf::Vector2f position) + { + powerup_position = position; + } + + PowerupType PowerupModel::getPowerupType() + { + return powerup_type; + } + + void PowerupModel::setPowerupType(PowerupType type) + { + powerup_type = type; + } + + float PowerupModel::getMovementSpeed() + { + return movement_speed; + } + + void PowerupModel::setMovementSpeed(float speed) + { + movement_speed = speed; + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupService.cpp b/Space-Invaders/Source/Powerup/PowerupService.cpp new file mode 100644 index 000000000..21cb9f313 --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupService.cpp @@ -0,0 +1,78 @@ +#include"../../Header/Powerup/PowerupService.h" +#include"../../Header/Powerup/PowerupConfig.h" +#include"../../Header/Powerup/PowerupController.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Powerup/Controllers/OutscalBombController.h" +#include"../../Header/Powerup/Controllers/RapidFireController.h" +#include"../../Header/Powerup/Controllers/ShieldController.h" +#include"../../Header/Powerup/Controllers/TripleLaserController.h" + +namespace Powerup +{ + using namespace Controller; + using namespace Global; + using namespace Collectible; + + PowerupService::PowerupService() + { + + } + + PowerupService::~PowerupService() + { + destroy(); + } + + void PowerupService::initialize() + { + + } + + void PowerupService::update() + { + for (int i = 0; i < powerup_list.size(); i++)powerup_list[i]->update(); + } + + void PowerupService::render() + { + for (int i = 0; i < powerup_list.size(); i++)powerup_list[i]->render(); + } + + PowerupController* PowerupService::createPowerup(PowerupType powerup_type) + { + switch (powerup_type) + { + case::Powerup::PowerupType::SHIELD: + return new ShieldController(Powerup::PowerupType::SHIELD); + + case::Powerup::PowerupType::RAPID_FIRE: + return new RapidFireController(Powerup::PowerupType::RAPID_FIRE); + + case::Powerup::PowerupType::TRIPPLE_LASER: + return new TripleLaserController(Powerup::PowerupType::TRIPPLE_LASER); + + case::Powerup::PowerupType::OUTSCAL_BOMB: + return new OutscalBombController(Powerup::PowerupType::OUTSCAL_BOMB); + } + } + + PowerupController* PowerupService::spawnPowerup(PowerupType powerup_type, sf::Vector2f position) + { + PowerupController* powerup_controller = createPowerup(powerup_type); + + powerup_controller->initialize(position); + powerup_list.push_back(powerup_controller); + return powerup_controller; + } + + void PowerupService::destroyPowerup(PowerupController* powerup_controller) + { + powerup_list.erase(std::remove(powerup_list.begin(), powerup_list.end(), powerup_controller), powerup_list.end()); + delete(powerup_controller); + } + + void PowerupService::destroy() + { + for (int i = 0; i < powerup_list.size(); i++) delete (powerup_list[i]); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Powerup/PowerupView.cpp b/Space-Invaders/Source/Powerup/PowerupView.cpp new file mode 100644 index 000000000..339c5621b --- /dev/null +++ b/Space-Invaders/Source/Powerup/PowerupView.cpp @@ -0,0 +1,68 @@ +#include "../../header/Powerup/PowerupView.h" +#include "../../header/Global/ServiceLocator.h" +#include "../../header/Global/Config.h" +#include "../../header/Powerup/PowerupController.h" +#include "../../header/Powerup/PowerupConfig.h" +#include"../../Header/Bullet/BulletConfig.h" + +namespace Powerup +{ + using namespace Global; + using namespace UI::UIElement; + + PowerupView::PowerupView() { createUIElements(); } + + PowerupView::~PowerupView() { destroy(); } + + void PowerupView::initialize(PowerupController* controller) + { + powerup_controller = controller; + initializeImage(); + } + + void PowerupView::createUIElements() + { + powerup_image = new ImageView(); + } + + void PowerupView::initializeImage() + { + powerup_image->initialize(getPowerupTexturePath(), powerup_sprite_width, powerup_sprite_height, powerup_controller->getCollectiblePosition()); + } + + void PowerupView::update() + { + powerup_image->setPosition(powerup_controller->getCollectiblePosition()); + powerup_image->update(); + } + + void PowerupView::render() + { + powerup_image->render(); + } + + sf::String PowerupView::getPowerupTexturePath() + { + switch (powerup_controller->getPowerupType()) + { + case::Powerup::PowerupType::TRIPPLE_LASER: + return Config::shield_texture_path; + + case::Powerup::PowerupType::SHIELD: + return Config::tripple_laser_texture_path; + + case::Powerup::PowerupType::RAPID_FIRE: + return Config::rapid_fire_texture_path; + + case::Powerup::PowerupType::OUTSCAL_BOMB: + return Config::outscal_bomb_texture_path; + } + } + + void PowerupView::destroy() + { + delete(powerup_image); + } + + +} \ No newline at end of file diff --git a/Space-Invaders/Source/Sound/SoundService.cpp b/Space-Invaders/Source/Sound/SoundService.cpp new file mode 100644 index 000000000..339da0074 --- /dev/null +++ b/Space-Invaders/Source/Sound/SoundService.cpp @@ -0,0 +1,47 @@ +#include"../../Header/Sound/SoundService.h" +#include"../../Header/Global/Config.h" + +namespace Sound +{ + using namespace Global; + + void SoundService::initialize() + { + loadBackgroundMusicFromFile(); + loadSoundFromFile(); + } + + void SoundService::loadBackgroundMusicFromFile() + { + if (!background_music.openFromFile(Config::background_music_path)) + printf("error loading background music file"); + } + + void SoundService::loadSoundFromFile() + { + if (!buffer_button_click.loadFromFile(Config::button_click_sound_path)) + printf("error loading background music file"); + } + + void SoundService::playSound(SoundType soundType) + { + switch (soundType) + { + case SoundType::BUTTON_CLICK: + sound_effect.setBuffer(buffer_button_click); + break; + default: + printf("invaild sound type"); + return; + } + + sound_effect.play(); + } + + void SoundService::playBackgroundMusic() + { + background_music.setLoop(true); + background_music.setVolume(background_music_volume); + background_music.play(); + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/Time/TimeService.cpp b/Space-Invaders/Source/Time/TimeService.cpp new file mode 100644 index 000000000..a10ad2e2b --- /dev/null +++ b/Space-Invaders/Source/Time/TimeService.cpp @@ -0,0 +1,37 @@ +#include "../../Header/Time/Timeservice.h" + +namespace Time +{ + void TimeService::initialize() + { + previous_time = std::chrono::steady_clock::now(); + delta_time = 0; + } + + void TimeService::update() + { + updateDeltaTime(); + } + + float TimeService::getDeltaTime() + { + return delta_time; + } + + void TimeService::updateDeltaTime() + { + delta_time = calculateDeltaTime(); + updatePreviousTime(); + } + + float TimeService::calculateDeltaTime() + { + int delta = std::chrono::duration_cast(std::chrono::steady_clock::now() - previous_time).count(); + return static_cast(delta) / static_cast(1000000); + } + + void TimeService::updatePreviousTime() + { + previous_time = std::chrono::steady_clock::now(); + } +} diff --git a/Space-Invaders/Source/UI/MainMenuUI/MainMenuUIController.cpp b/Space-Invaders/Source/UI/MainMenuUI/MainMenuUIController.cpp new file mode 100644 index 000000000..b6989132b --- /dev/null +++ b/Space-Invaders/Source/UI/MainMenuUI/MainMenuUIController.cpp @@ -0,0 +1,126 @@ +#include "../../Header/UI/MainMenuUI/MainMenuUIController.h" +#include "../../Header/Main/GameService.h" +#include "../../Header/Global/ServiceLocator.h" +#include"../../Header/Graphic/GraphicService.h" +#include"../../Header/Global/Config.h" +#include"../../Header/Sound/SoundService.h" +#include"../../Header/Event/EventService.h" + +namespace UI +{ + namespace MainMenu + { + using namespace Global; + using namespace Main; + using namespace UIElement; + using namespace Sound; + + MainMenuUIController::MainMenuUIController() + { + createImage(); + createButtons(); + } + + MainMenuUIController::~MainMenuUIController() + { + destroy(); + } + + + void MainMenuUIController::initialize() + { + initializeBackgroundImage(); + initializeButtons(); + registerButtonCallback(); + } + + void MainMenuUIController::createImage() + { + background_image = new ImageView(); + } + + void MainMenuUIController::createButtons() + { + play_button = new ButtonView(); + instructions_button = new ButtonView(); + quit_button = new ButtonView(); + } + + void MainMenuUIController::initializeBackgroundImage() + { + sf::RenderWindow* game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + + background_image->initialize(Config::background_texture_path, game_window->getSize().x, game_window->getSize().y, sf::Vector2f(0, 0)); + + background_image->setImageAlpha(background_alpha); + } + + void MainMenuUIController::initializeButtons() + { + play_button->initialize("Play Button", Config::play_button_texture_path, button_width, button_height, sf::Vector2f(0, play_button_y_position)); + instructions_button->initialize("Instructions Button", Config::instructions_button_texture_path, button_width, button_height, sf::Vector2f(0, instructions_button_y_position)); + quit_button->initialize("Quit button", Config::quit_button_texture_path, button_width, button_height, sf::Vector2f(0, quit_button_y_position)); + + play_button->setCentreAlinged(); + instructions_button->setCentreAlinged(); + quit_button->setCentreAlinged(); + } + + void MainMenuUIController::registerButtonCallback() + { + play_button->registerCallbackFunction(std::bind(&MainMenuUIController::playButtonCallback, this)); + instructions_button->registerCallbackFunction(std::bind(&MainMenuUIController::instructionsButtonCallback, this)); + quit_button->registerCallbackFunction(std::bind(&MainMenuUIController::quitButtonCallback, this)); + } + + void MainMenuUIController::playButtonCallback() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BUTTON_CLICK); + GameService::setGameState(GameState::GAMEPLAY); + } + + void MainMenuUIController::instructionsButtonCallback() + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BUTTON_CLICK); + } + + void MainMenuUIController::quitButtonCallback() + { + ServiceLocator::getInstance()->getGraphicService()->getGameWindow()->close(); + } + + void MainMenuUIController::update() + { + background_image->update(); + play_button->update(); + instructions_button->update(); + quit_button->update(); + } + + void MainMenuUIController::render() + { + background_image->render(); + play_button->render(); + instructions_button->render(); + quit_button->render(); + } + + void MainMenuUIController::show() + { + background_image->show(); + play_button->show(); + instructions_button->show(); + quit_button->show(); + + ServiceLocator::getInstance()->getSoundService()->playBackgroundMusic(); + } + + void MainMenuUIController::destroy() + { + delete(play_button); + delete(instructions_button); + delete(quit_button); + delete(background_image); + } + } +} diff --git a/Space-Invaders/Source/UI/UIElement/ButtonView.cpp b/Space-Invaders/Source/UI/UIElement/ButtonView.cpp new file mode 100644 index 000000000..594e2bb58 --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/ButtonView.cpp @@ -0,0 +1,64 @@ +#include"../../Header/UI/UIElement/ButtonView.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Event/EventService.h" +#include"../../Header/Sound/SoundService.h" + +namespace UI +{ + namespace UIElement + { + using namespace Event; + using namespace Global; + + ButtonView::ButtonView() = default; + + ButtonView::~ButtonView() = default; + + void ButtonView::initialize(sf::String title, sf::String texture_path, float button_width, float button_height, sf::Vector2f position) + { + button_title = title; + ImageView::initialize(texture_path, button_width, button_height, position); + } + + void ButtonView::update() + { + ImageView::update(); + + if (ui_state == UIState::VISIBLE) + { + handleButtonInteraction(); + } + } + + void ButtonView::render() + { + ImageView::render(); + } + + void ButtonView::registerCallbackFunction(CallbackFunction button_callback) + { + callback_function = button_callback; + } + + void ButtonView::handleButtonInteraction() + { + sf::Vector2f mouse_position = sf::Vector2f(sf::Mouse::getPosition(*game_window)); + + if (clickedButton(&image_sprite, mouse_position)) + { + if (callback_function)callback_function(); + } + } + + bool ButtonView::clickedButton(sf::Sprite* button_sprite, sf::Vector2f mouse_position) + { + return ServiceLocator::getInstance()->getEventService()->pressedLeftMouseButton() && + button_sprite->getGlobalBounds().contains(mouse_position); + } + + void ButtonView::printButtonClicked() + { + printf("Clicked %s\n", button_title.toAnsiString().c_str()); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/ImageView.cpp b/Space-Invaders/Source/UI/UIElement/ImageView.cpp new file mode 100644 index 000000000..5d0d32f60 --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/ImageView.cpp @@ -0,0 +1,81 @@ +#include"../../Header/UI/UIElement/ImageView.h" + +namespace UI +{ + namespace UIElement + { + ImageView::ImageView() = default; + + ImageView::~ImageView() = default; + + void ImageView::initialize(sf::String texture_path, float image_width, float image_height, sf::Vector2f position) + { + UIView::initialize(); + setTexture(texture_path); + setScale(image_width, image_height); + setPosition(position); + + } + + void ImageView::update() + { + UIView::update(); + } + + void ImageView::render() + { + UIView::render(); + + if (ui_state == UIState::VISIBLE) + { + game_window->draw(image_sprite); + } + } + + void ImageView::setTexture(sf::String texture_path) + { + if (image_texture.loadFromFile(texture_path)) + { + image_sprite.setTexture(image_texture); + } + } + + void ImageView::setScale(float width, float height) + { + float scale_x = width / image_sprite.getTexture()->getSize().x; + float scale_y = height / image_sprite.getTexture()->getSize().y; + + image_sprite.setScale(scale_x, scale_y); + } + + void ImageView::setPosition(sf::Vector2f position) + { + image_sprite.setPosition(position); + } + + void ImageView::setRotation(float rotation_angle) + { + image_sprite.setRotation(rotation_angle); + } + + void ImageView::setImageAlpha(float alpha) + { + sf::Color color = image_sprite.getColor(); + color.a = alpha; + image_sprite.setColor(color); + } + + void ImageView::setCentreAlinged() + { + float x_position = (game_window->getSize().x / 2) - (image_sprite.getGlobalBounds().width / 2); + float y_position = image_sprite.getGlobalBounds().getPosition().y; + + image_sprite.setPosition(x_position, y_position); + } + + void ImageView::setOriginAtCentre() + { + image_sprite.setOrigin(image_sprite.getLocalBounds().width / 2, image_sprite.getLocalBounds().height / 2); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/TextView.cpp b/Space-Invaders/Source/UI/UIElement/TextView.cpp new file mode 100644 index 000000000..228c32e40 --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/TextView.cpp @@ -0,0 +1,95 @@ +#include"../../Header/UI/UIElement/TextView.h" +#include"../../Header/Global/Config.h" + +namespace UI +{ + namespace UIElement + { + using namespace Global; + + sf::Font TextView::font_bubble_bobble; + sf::Font TextView::font_DS_DIGIB; + + TextView::TextView() = default; + + TextView::~TextView() = default; + + void TextView::initialize(sf::String text_value, sf::Vector2f position, FontType font_type, int font_size, sf::Color color) + { + UIView::initialize(); + + setText(text_value); + setTextPosition(position); + setFont(font_type); + setFontSize(font_size); + setTextColor(color); + } + + void TextView::update() + { + UIView::update(); + } + + void TextView::render() + { + UIView::render(); + + if (ui_state == UIState::VISIBLE) + { + game_window->draw(text); + } + } + + void TextView::initializeTextView() + { + loadFont(); + } + + void TextView::loadFont() + { + font_bubble_bobble.loadFromFile(Config::bubble_bobble_font_path); + font_DS_DIGIB.loadFromFile(Config::DS_DIGIB_font_path); + } + + void TextView::setText(sf::String text_value) + { + text.setString(text_value); + } + + void TextView::setFont(FontType font_type) + { + switch (font_type) + { + case FontType::BUBBLE_BOBBLE: + text.setFont(font_bubble_bobble); + break; + case FontType::DS_DIGIB: + text.setFont(font_DS_DIGIB); + break; + } + } + + void TextView::setFontSize(int font_size) + { + text.setCharacterSize(font_size); + } + + void TextView::setTextPosition(sf::Vector2f position) + { + text.setPosition(position); + } + + void TextView::setTextColor(sf::Color color) + { + text.setFillColor(color); + } + + void TextView::setTextCentreAligned() + { + float x_position = (game_window->getSize().x - text.getLocalBounds().width) / 2; + float y_position = text.getGlobalBounds().getPosition().y; + + text.setPosition(sf::Vector2f(x_position, y_position)); + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIElement/UIView.cpp b/Space-Invaders/Source/UI/UIElement/UIView.cpp new file mode 100644 index 000000000..82498c616 --- /dev/null +++ b/Space-Invaders/Source/UI/UIElement/UIView.cpp @@ -0,0 +1,43 @@ +#include"../../Header/UI/UIElement/UIView.h" +#include"../../Header/Global/ServiceLocator.h" +#include"../../Header/Graphic/GraphicService.h" + +namespace UI +{ + namespace UIElement + { + using namespace Global; + using namespace Graphic; + + UIView::UIView() = default; + + UIView::~UIView() = default; + + void UIView::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + ui_state = UIState::VISIBLE; + } + + + void UIView::update() + { + + } + + void UIView::render() + { + + } + + void UIView::show() + { + ui_state = UIState::VISIBLE; + } + + void UIView::hide() + { + ui_state = UIState::HIDDEN; + } + } +} \ No newline at end of file diff --git a/Space-Invaders/Source/UI/UIService.cpp b/Space-Invaders/Source/UI/UIService.cpp new file mode 100644 index 000000000..97e48de07 --- /dev/null +++ b/Space-Invaders/Source/UI/UIService.cpp @@ -0,0 +1,75 @@ +#include "../../Header/UI/UIService.h" +#include "../../Header/Main/GameService.h" +#include"../../Header/UI/UIElement/TextView.h" + +namespace UI +{ + using namespace Main; + using namespace MainMenu; + using namespace UIElement; + using namespace Interface; + + UIService::UIService() + { + main_menu_controller = nullptr; + createControllers(); + } + + void UIService::createControllers() + { + main_menu_controller = new MainMenuUIController(); + } + + UIService::~UIService() + { + destory(); + } + + void UIService::initialize() + { + TextView::initializeTextView(); + initializeControllers(); + } + + void UIService::initializeControllers() + { + main_menu_controller->initialize(); + } + + void UIService::update() + { + IUIController* ui_controller = getCurrentUIController(); + if (ui_controller)ui_controller->update(); + } + + void UIService::render() + { + IUIController* ui_controller = getCurrentUIController(); + if (ui_controller)ui_controller->render(); + } + + void UIService::showScreen() + { + IUIController* ui_controller = getCurrentUIController(); + if (ui_controller)ui_controller->show(); + } + + + + IUIController* UIService::getCurrentUIController() + { + switch (GameService::getGameState()) + { + case GameState::MAIN_MENU: + return main_menu_controller; + + default: + return nullptr;; + } + } + + void UIService::destory() + { + delete(main_menu_controller); + } +} diff --git a/Space-Invaders/Space-Invaders.vcxproj b/Space-Invaders/Space-Invaders.vcxproj index 6f7fa388d..39c862b99 100644 --- a/Space-Invaders/Space-Invaders.vcxproj +++ b/Space-Invaders/Space-Invaders.vcxproj @@ -133,6 +133,108 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Space-Invaders/Space-Invaders.vcxproj.filters b/Space-Invaders/Space-Invaders.vcxproj.filters index ce0c35ccf..19ed2e652 100644 --- a/Space-Invaders/Space-Invaders.vcxproj.filters +++ b/Space-Invaders/Space-Invaders.vcxproj.filters @@ -18,5 +18,307 @@ Source Files + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + \ No newline at end of file diff --git a/Space-Invaders/main.cpp b/Space-Invaders/main.cpp index 7d5f90dff..fa3b541de 100644 --- a/Space-Invaders/main.cpp +++ b/Space-Invaders/main.cpp @@ -1,5 +1,120 @@ +#include +#include +#include "../../Header/Main/GameService.h" +using namespace std; +using namespace Main; +/* +class Player +{ + private: + int health = 3; + sf::Vector2f position = sf::Vector2f(200.0f, 100.0f); + int movement_Speed = 5; + int player_Score = 0; + + public: + + //Properties + sf :: Texture player_texture; + sf::Sprite player_sprite; + + int getScore() + { + return player_Score; + }; + + int getMoveSpeed() + { + return movement_Speed; + }; + + sf::Vector2f getPosition() + { + return position; + }; + void setScore(int newScore) + { + player_Score = newScore; + }; + + void takeDamage() + { + + }; + + //Functions + void move(float offsetX ) + { + position.x += offsetX; + + }; + + void shootBullets() + { + + }; + +}; */ int main() { - return 0; + /*//Define the video mode(dimensions) + sf::VideoMode videomode = sf::VideoMode(800, 600); + + //create a window object with specific dimensions and a title + sf::RenderWindow window(videomode, "Player Window"); + + //using default constructor + Player player; + + //laod player ship texture + player.player_texture.loadFromFile("assets/textures/player_ship.png"); + + //set the player type variable to the player ship texture + player.player_sprite.setTexture(player.player_texture); + + while (window.isOpen()) + { + sf::Event event; + while (window.pollEvent(event)) + { + //check for window closure + if (event.type == sf::Event::Closed) + window.close(); + } + + //handle keyboard input + if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) + { + player.move(-1.0f * player.getMoveSpeed()); + } + + if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) + { + player.move(1.0f * player.getMoveSpeed()); + } + + //clear the window + window.clear(sf::Color::Black); + + //set the position of the player sprite + player.player_sprite.setPosition(player.getPosition()); + + //draw the player sprite + window.draw(player.player_sprite); + + //display what was drawn + window.display(); + }*/ + + GameService* game_service = new GameService; + game_service->ignite(); + + while (game_service->isRunning()) + { + game_service->update(); + game_service->render(); + + } + } \ No newline at end of file diff --git a/Space-Invaders/sfml/include/SFML/Config.hpp b/Space-Invaders/sfml/include/SFML/Config.hpp index f4ea4ef3e..3093a7a51 100644 --- a/Space-Invaders/sfml/include/SFML/Config.hpp +++ b/Space-Invaders/sfml/include/SFML/Config.hpp @@ -31,7 +31,7 @@ //////////////////////////////////////////////////////////// #define SFML_VERSION_MAJOR 2 #define SFML_VERSION_MINOR 6 -#define SFML_VERSION_PATCH 0 +#define SFML_VERSION_PATCH 1 //////////////////////////////////////////////////////////// diff --git a/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb index 9371818c4..bbd97a4b6 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-audio-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb index 9371818c4..bbd97a4b6 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-audio-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb b/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb index eec00db20..e0cd93576 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-audio.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb index c0bed6ba8..d187d9728 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb index c0bed6ba8..d187d9728 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-graphics-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb b/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb index c516163a0..310a084ae 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-graphics.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb index 3e17d4a22..432660dd8 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-main-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb index 3e17d4a22..432660dd8 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-main-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb index 7afce5265..446f1fb80 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-network-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb index 7afce5265..446f1fb80 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-network-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-network.pdb b/Space-Invaders/sfml/lib/Debug/sfml-network.pdb index 93ec6553c..fa073311f 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-network.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-network.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb index 2ba28522a..aa448263a 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-system-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb index 2ba28522a..aa448263a 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-system-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-system.pdb b/Space-Invaders/sfml/lib/Debug/sfml-system.pdb index 59b5195a4..ea487f4f0 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-system.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-system.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb b/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb index 4a11994b0..98a4c966e 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-window-s-d.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb b/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb index 4a11994b0..98a4c966e 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-window-s.pdb differ diff --git a/Space-Invaders/sfml/lib/Debug/sfml-window.pdb b/Space-Invaders/sfml/lib/Debug/sfml-window.pdb index 332a83ca4..1e2442bd4 100644 Binary files a/Space-Invaders/sfml/lib/Debug/sfml-window.pdb and b/Space-Invaders/sfml/lib/Debug/sfml-window.pdb differ diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake index f8b915b60..f28497b6c 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfig.cmake @@ -144,5 +144,5 @@ if (NOT SFML_FOUND) endif() if (SFML_FOUND AND NOT SFML_FIND_QUIETLY) - message(STATUS "Found SFML 2.6.0 in ${CMAKE_CURRENT_LIST_DIR}") + message(STATUS "Found SFML 2.6.1 in ${CMAKE_CURRENT_LIST_DIR}") endif() diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake index b2208ca9f..25db87605 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLConfigVersion.cmake @@ -9,19 +9,19 @@ # The variable CVF_VERSION must be set before calling configure_file(). -set(PACKAGE_VERSION "2.6.0") +set(PACKAGE_VERSION "2.6.1") if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() - if("2.6.0" MATCHES "^([0-9]+)\\.") + if("2.6.1" MATCHES "^([0-9]+)\\.") set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") endif() else() - set(CVF_VERSION_MAJOR "2.6.0") + set(CVF_VERSION_MAJOR "2.6.1") endif() if(PACKAGE_FIND_VERSION_RANGE) diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake index 1c1c3c062..852e1a8d4 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLSharedTargets.cmake @@ -7,7 +7,7 @@ if(CMAKE_VERSION VERSION_LESS "2.8.3") message(FATAL_ERROR "CMake >= 2.8.3 required") endif() cmake_policy(PUSH) -cmake_policy(VERSION 2.8.3...3.24) +cmake_policy(VERSION 2.8.3...3.25) #---------------------------------------------------------------- # Generated CMake target import file. #---------------------------------------------------------------- diff --git a/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake b/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake index 7257de655..419bb1b85 100644 --- a/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake +++ b/Space-Invaders/sfml/lib/cmake/SFML/SFMLStaticTargets.cmake @@ -7,7 +7,7 @@ if(CMAKE_VERSION VERSION_LESS "2.8.3") message(FATAL_ERROR "CMake >= 2.8.3 required") endif() cmake_policy(PUSH) -cmake_policy(VERSION 2.8.3...3.24) +cmake_policy(VERSION 2.8.3...3.25) #---------------------------------------------------------------- # Generated CMake target import file. #----------------------------------------------------------------