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..65930cdac --- /dev/null +++ b/Space-Invaders/Header/Bullet/BulletView.h @@ -0,0 +1,33 @@ +#pragma once +#include + +namespace Bullet +{ + class BulletController; + enum class BulletType; + + class BulletView + { + private: + const float bullet_sprite_width = 18.f; + const float bullet_sprite_height = 18.f; + + sf::RenderWindow* game_window; + sf::Texture bullet_texture; + sf::Sprite bullet_sprite; + + BulletController* bullet_controller; + + void initializeImage(BulletType type); + void scaleImage(); + + 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/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..4d3444f91 --- /dev/null +++ b/Space-Invaders/Header/Elements/Bunker/BunkerView.h @@ -0,0 +1,36 @@ +#pragma once +#include + +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; + sf::RenderWindow* game_window; + + sf::Texture bunker_texture; + sf::Sprite bunker_sprite; + + + + void scaleSprite(); + void initializeImage(); + + 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/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..73209a605 --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyConfig.h @@ -0,0 +1,26 @@ +#pragma once + +namespace Enemy +{ + enum class EnemyType + { + ZAPPER, + SUBZERO, + //UFO, + //THUNDER_SNAKE, + }; + + enum class EnemyState + { + PATROLLING, + ATTACK, + DEAD, + }; + + enum class MovementDirection + { + LEFT, + RIGHT, + DOWN, + }; +} \ 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..7f787156f --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyController.h @@ -0,0 +1,49 @@ +#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 moveLeft(); + //void moveRight(); + //void moveDown(); + + 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..9d2b9931d --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyService.h @@ -0,0 +1,36 @@ +#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..824e869b6 --- /dev/null +++ b/Space-Invaders/Header/Enemy/EnemyView.h @@ -0,0 +1,33 @@ +#pragma once +#include + +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; + + sf::RenderWindow* game_window; + sf::Texture enemy_texture; + sf::Sprite enemy_sprite; + + void initializeEnemySprite(EnemyType type); + void scaleEnemySprite(); + + 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..fb2b5a0d4 --- /dev/null +++ b/Space-Invaders/Header/Gameplay/GameplayView.h @@ -0,0 +1,25 @@ +#pragma once +#include + +namespace Gameplay +{ + class GameplayView + { + private: + + sf::RenderWindow* game_window; + sf::Texture background_texture; + sf::Sprite background_sprite; + + void initializeBackGroundSprite(); + void scaleBackGroundSprite(); + + 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..b007104b0 --- /dev/null +++ b/Space-Invaders/Header/Global/ServiceLocator.h @@ -0,0 +1,57 @@ +#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" + +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; + + 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(); + }; +} diff --git a/Space-Invaders/Header/Graphic/GraphicService.h b/Space-Invaders/Header/Graphic/GraphicService.h new file mode 100644 index 000000000..4a4680459 --- /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::Blue; + + 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..916b7e680 --- /dev/null +++ b/Space-Invaders/Header/Player/PlayerView.h @@ -0,0 +1,35 @@ +#pragma once +#include + +namespace Player +{ + class PlayerController; + + class PlayerView + { + private: + + const float player_sprite_width = 60.0f; + const float player_sprite_height = 60.0f; + sf::Texture player_texture; + sf::Sprite player_sprite; + + PlayerController* player_controller; + + sf::RenderWindow* game_window; + + void initializePlayerSprite(); + void scalePlayerSprite(); + + + + public: + PlayerView(); + ~PlayerView(); + + void initialize(PlayerController* 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/MainMenuUI/MainMenuUIController.h b/Space-Invaders/Header/UI/MainMenuUI/MainMenuUIController.h new file mode 100644 index 000000000..73e91ba75 --- /dev/null +++ b/Space-Invaders/Header/UI/MainMenuUI/MainMenuUIController.h @@ -0,0 +1,52 @@ +#pragma once +#include + +namespace UI +{ + namespace MainMenu + { + class MainMenuUIController + { + private: + + const float button_width = 400.f; + const float button_height = 140.f; + + sf::RenderWindow* game_window; + + sf::Texture background_texture; + sf::Sprite background_sprite; + + sf::Texture play_button_texture; + sf::Sprite play_button_sprite; + + sf::Texture instructions_button_texture; + sf::Sprite instructions_button_sprite; + + sf::Texture quit_button_texture; + sf::Sprite quit_button_sprite; + + void initializeBackgroundSprite(); + void scaleBackgroundSprite(); + + void initializeButtons(); + bool LoadButtonTexturesFromFile(); + void setButtonSprites(); + + void scaleAllButtons(); + void scaleButton(sf::Sprite* button_to_scale); + void positionButtons(); + + void processButtonInteractions(); + bool clickedButton(sf::Sprite*, sf::Vector2f); + + public: + MainMenuUIController(); + + void initialize(); + void update(); + void render(); + + }; + } +} diff --git a/Space-Invaders/Header/UI/UIService.h b/Space-Invaders/Header/UI/UIService.h new file mode 100644 index 000000000..0a33341ce --- /dev/null +++ b/Space-Invaders/Header/UI/UIService.h @@ -0,0 +1,28 @@ +#pragma once +#include "../../Header/UI/MainMenuUI/MainMenuUIController.h" + +namespace UI +{ + class UIService + { + private: + + MainMenu::MainMenuUIController* main_menu_controller; + + + void createControllers(); + void initializeControllers(); + void destory(); + + + public: + UIService(); + ~UIService(); + + void initialize(); + void update(); + void render(); + + + }; +} 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..4dedb6d15 --- /dev/null +++ b/Space-Invaders/Source/Bullet/BulletView.cpp @@ -0,0 +1,74 @@ +#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; + + BulletView::BulletView() + { + + } + + BulletView::~BulletView() + { + + } + + void BulletView::initialize(BulletController* controller) + { + bullet_controller = controller; + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + initializeImage(bullet_controller->getBulletType()); + } + + void BulletView::initializeImage(BulletType type) + { + switch (type) + { + case::Bullet::BulletType::LASER_BULLET: + if (bullet_texture.loadFromFile(Config::laser_bullet_texture_path)) + { + bullet_sprite.setTexture(bullet_texture); + scaleImage(); + } + break; + case::Bullet::BulletType::FROST_BULLET: + if(bullet_texture.loadFromFile(Config::frost_beam_texture_path)) + { + bullet_sprite.setTexture(bullet_texture); + scaleImage(); + } + break; + case::Bullet::BulletType::TORPEDO: + if (bullet_texture.loadFromFile(Config::torpedoe_texture_path)) + { + bullet_sprite.setTexture(bullet_texture); + scaleImage(); + } + break; + + } + } + + void BulletView::scaleImage() + { + bullet_sprite.setScale( + static_cast(bullet_sprite_width) / bullet_sprite.getTexture()->getSize().x, + static_cast(bullet_sprite_height) / bullet_sprite.getTexture()->getSize().y + ); + } + + void BulletView::update() + { + bullet_sprite.setPosition(bullet_controller->getProjectilePosition()); + } + + void BulletView::render() + { + game_window->draw(bullet_sprite); + } +} \ 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..d5c0b2e82 --- /dev/null +++ b/Space-Invaders/Source/ElementService/Bunker/BunkerView.cpp @@ -0,0 +1,56 @@ +#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; + + BunkerView::BunkerView() + { + + } + + BunkerView::~BunkerView() + { + + } + + void BunkerView::initialize(BunkerController* controller) + { + bunker_controller = controller; + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + initializeImage(); + } + + void BunkerView::initializeImage() + { + if (bunker_texture.loadFromFile(Config::bunker_texture_path)) + { + bunker_sprite.setTexture(bunker_texture); + scaleSprite(); + } + } + + void BunkerView::scaleSprite() + { + bunker_sprite.setScale( + static_cast(bunker_sprite_width) / bunker_sprite.getTexture()->getSize().x, + static_cast(bunker_sprite_height) / bunker_sprite.getTexture()->getSize().y + ); + } + + void BunkerView::update() + { + bunker_sprite.setPosition(bunker_controller->getBunkerPosition()); + } + + void BunkerView::render() + { + game_window->draw(bunker_sprite); + } + } +} \ 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..815f257d0 --- /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::LASER_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/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..e059fca51 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyController.cpp @@ -0,0 +1,164 @@ +#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/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::move() + { + switch (enemy_model->getMovementDirection()) + { + case::Enemy::MovementDirection::LEFT: + moveLeft(); + break; + + case::Enemy::MovementDirection::RIGHT: + moveRight(); + break; + + case::Enemy::MovementDirection::DOWN: + moveDown(); + break; + } + }*/ + + /*void EnemyController::moveLeft() + { + // Get current pos + // Move left by multiplying by speed and delta time + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + currentPosition.x -= enemy_model->enemy_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + //check for bounds + if (currentPosition.x <= enemy_model->left_most_position.x) + { + //if reached the left most pos + //start moving down + //set ref pos for the downwards movement + enemy_model->setMovementDirection(MovementDirection::DOWN); + enemy_model->setReferencePosition(currentPosition); + } + else enemy_model->setEnemyPosition(currentPosition); + } + + void EnemyController::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 EnemyController::moveDown() + { + sf::Vector2f currentPosition = enemy_model->getEnemyPosition(); + currentPosition.y += enemy_model->enemy_movement_speed * ServiceLocator::getInstance()->getTimeService()->getDeltaTime(); + + //check if enemy has moved the specified distance downwards + if (currentPosition.y >= enemy_model->getReferencePosition().y + enemy_model->vertical_travel_distance) + { + //check where to move them based on position + 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); + }*/ + + 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..599a3287f --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyService.cpp @@ -0,0 +1,88 @@ +#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" + +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() % 2; + 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); + } + } + + 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..135d94544 --- /dev/null +++ b/Space-Invaders/Source/Enemy/EnemyView.cpp @@ -0,0 +1,64 @@ +#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; + + + EnemyView::EnemyView() { } + + EnemyView::~EnemyView() { } + + void EnemyView::initialize(EnemyController* controller) + { + enemy_controller = controller; + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + initializeEnemySprite(enemy_controller->getEnemyType()); + } + + void EnemyView::initializeEnemySprite(EnemyType type) + { + switch (type) + { + case::Enemy::EnemyType::SUBZERO: + if (enemy_texture.loadFromFile(Config::subzero_texture_path)) + { + enemy_sprite.setTexture(enemy_texture); + scaleEnemySprite(); + } + break; + case::Enemy::EnemyType::ZAPPER: + if (enemy_texture.loadFromFile(Config::zapper_texture_path)) + { + enemy_sprite.setTexture(enemy_texture); + scaleEnemySprite(); + } + break; + } + + } + + void EnemyView::scaleEnemySprite() + { + enemy_sprite.setScale( + static_cast(enemy_sprite_width) / enemy_sprite.getTexture()->getSize().x, + static_cast(enemy_sprite_height) / enemy_sprite.getTexture()->getSize().y + ); + } + + void EnemyView::update() + { + enemy_sprite.setPosition(enemy_controller->getEnemyPosition()); + } + + void EnemyView::render() + { + game_window->draw(enemy_sprite); + } +} 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..6c1437368 --- /dev/null +++ b/Space-Invaders/Source/Gameplay/GameplayView.cpp @@ -0,0 +1,53 @@ +#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; + + GameplayView::GameplayView() + { + + } + + GameplayView::~GameplayView() + { + + } + + void GameplayView::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + initializeBackGroundSprite(); + } + + void GameplayView::initializeBackGroundSprite() + { + if (background_texture.loadFromFile(Config::background_texture_path)) + { + background_sprite.setTexture(background_texture); + scaleBackGroundSprite(); + } + } + + void GameplayView::scaleBackGroundSprite() + { + background_sprite.setScale( + static_cast(game_window->getSize().x) / background_sprite.getTexture()->getSize().x, + static_cast(game_window->getSize().y) / background_sprite.getTexture()->getSize().y + ); + } + + void GameplayView::update() + { + + } + + void GameplayView::render() + { + game_window->draw(background_sprite); + } +} \ 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..dd1566cb6 --- /dev/null +++ b/Space-Invaders/Source/Global/ServiceLocator.cpp @@ -0,0 +1,170 @@ +#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; + + 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; + 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(); + } + + 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); + 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(); + } + + 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(); + } + 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(); + + } + + 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; + } +} \ 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..b8e7376c0 --- /dev/null +++ b/Space-Invaders/Source/Player/PlayerView.cpp @@ -0,0 +1,53 @@ +#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; + + PlayerView::PlayerView() + { + + } + + PlayerView::~PlayerView() + { + + } + + void PlayerView::initialize(PlayerController* controller) + { + player_controller = controller; + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + initializePlayerSprite(); + } + + void PlayerView::initializePlayerSprite() + { + if (player_texture.loadFromFile(Config::player_texture_path)) + { + player_sprite.setTexture(player_texture); + scalePlayerSprite(); + } + } + + void PlayerView::scalePlayerSprite() + { + player_sprite.setScale( + static_cast(player_sprite_width) / player_sprite.getTexture()->getSize().x, + static_cast(player_sprite_height) / player_sprite.getTexture()->getSize().y + ); + } + + void PlayerView::update() + { + player_sprite.setPosition(player_controller->getPlayerPosition()); + } + + void PlayerView::render() + { + game_window->draw(player_sprite); + } +} \ 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..b33047c91 --- /dev/null +++ b/Space-Invaders/Source/UI/MainMenuUI/MainMenuUIController.cpp @@ -0,0 +1,120 @@ +#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" + +namespace UI +{ + namespace MainMenu + { + using namespace Global; + using namespace Main; + using namespace Graphic; + using namespace Event; + using namespace Sound; + + MainMenuUIController::MainMenuUIController() + { + game_window = nullptr; + } + void MainMenuUIController::processButtonInteractions() + { + sf::Vector2f mouse_position = sf::Vector2f(sf::Mouse::getPosition(*game_window)); + if (clickedButton(&play_button_sprite, mouse_position)) + { + ServiceLocator::getInstance()->getSoundService()->playSound(SoundType::BUTTON_CLICK); + ServiceLocator::getInstance()->getSoundService()->playBackgroundMusic(); + GameService::setGameState(GameState::GAMEPLAY); + } + if (clickedButton(&instructions_button_sprite, mouse_position)) + { + printf("clicked instructions button \\n"); + } + if (clickedButton(&quit_button_sprite, mouse_position)) + { + game_window->close(); + } + } + bool MainMenuUIController::clickedButton(sf::Sprite* button_sprite, sf::Vector2f mouse_position) + { + EventService* event_service = ServiceLocator::getInstance()->getEventService(); + return event_service->pressedLeftMouseButton() && button_sprite->getGlobalBounds().contains(mouse_position); + } + void MainMenuUIController::initialize() + { + game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow(); + initializeBackgroundSprite(); + initializeButtons(); + } + void MainMenuUIController::initializeBackgroundSprite() + { + if (background_texture.loadFromFile(Config::background_texture_path)) + { + background_sprite.setTexture(background_texture); + scaleBackgroundSprite(); + } + } + void MainMenuUIController::scaleBackgroundSprite() + { + background_sprite.setScale( + static_cast(game_window->getSize().x) / background_sprite.getTexture()->getSize().x, + static_cast(game_window->getSize().y) / background_sprite.getTexture()->getSize().y + ); + } + void MainMenuUIController::initializeButtons() + { + if (LoadButtonTexturesFromFile()) + { + setButtonSprites(); + scaleAllButtons(); + positionButtons(); + } + } + bool MainMenuUIController::LoadButtonTexturesFromFile() + { + return play_button_texture.loadFromFile(Config::play_button_texture_path) && + instructions_button_texture.loadFromFile(Config::instructions_button_texture_path) && + quit_button_texture.loadFromFile(Config::quit_button_texture_path); + } + void MainMenuUIController::setButtonSprites() + { + play_button_sprite.setTexture(play_button_texture); + instructions_button_sprite.setTexture(instructions_button_texture); + quit_button_sprite.setTexture(quit_button_texture); + } + void MainMenuUIController::scaleAllButtons() + { + scaleButton(&play_button_sprite); + scaleButton(&instructions_button_sprite); + scaleButton(&quit_button_sprite); + } + void MainMenuUIController::scaleButton(sf::Sprite* button_to_scale) + { + button_to_scale->setScale( + button_width / button_to_scale->getTexture()->getSize().x, + button_height / button_to_scale->getTexture()->getSize().y + ); + } + void MainMenuUIController::positionButtons() + { + float x_position = (static_cast(game_window->getSize().x) / 2) - button_width / 2; + + play_button_sprite.setPosition({ x_position,500.f }); + instructions_button_sprite.setPosition({ x_position,700.f }); + quit_button_sprite.setPosition({ x_position,900.f }); + } + void MainMenuUIController::update() + { + processButtonInteractions(); + } + void MainMenuUIController::render() + { + game_window->draw(background_sprite); + game_window->draw(play_button_sprite); + game_window->draw(instructions_button_sprite); + game_window->draw(quit_button_sprite); + } + } +} diff --git a/Space-Invaders/Source/UI/UIService.cpp b/Space-Invaders/Source/UI/UIService.cpp new file mode 100644 index 000000000..b01dd6a0d --- /dev/null +++ b/Space-Invaders/Source/UI/UIService.cpp @@ -0,0 +1,59 @@ +#include "../../Header/UI/UIService.h" +#include"../../Header/UI/MainMenuUI/MainMenuUIController.h" +#include "../../Header/Main/GameService.h" + +namespace UI +{ + using namespace Main; + using namespace MainMenu; + UIService::UIService() + { + main_menu_controller = nullptr; + createControllers(); + } + + void UIService::createControllers() + { + main_menu_controller = new MainMenuUIController(); + } + + UIService::~UIService() + { + destory(); + } + + void UIService::initialize() + { + initializeControllers(); + } + + void UIService::update() + { + switch (GameService::getGameState()) + { + case GameState::MAIN_MENU: + return main_menu_controller->update(); + break; + } + } + + void UIService::render() + { + switch (GameService::getGameState()) + { + case GameState::MAIN_MENU: + return main_menu_controller->render(); + break; + } + } + + void UIService::initializeControllers() + { + main_menu_controller->initialize(); + } + + void UIService::destory() + { + delete(main_menu_controller); + } +} diff --git a/Space-Invaders/Space-Invaders.vcxproj b/Space-Invaders/Space-Invaders.vcxproj index 6f7fa388d..37c794b25 100644 --- a/Space-Invaders/Space-Invaders.vcxproj +++ b/Space-Invaders/Space-Invaders.vcxproj @@ -133,6 +133,77 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Space-Invaders/Space-Invaders.vcxproj.filters b/Space-Invaders/Space-Invaders.vcxproj.filters index ce0c35ccf..f321cb9a8 100644 --- a/Space-Invaders/Space-Invaders.vcxproj.filters +++ b/Space-Invaders/Space-Invaders.vcxproj.filters @@ -18,5 +18,130 @@ 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 + \ 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. #----------------------------------------------------------------