Feature 6 barriers and sounds

Space-Invaders/Header/Element/Bunker/BunkerController.h

@@ -0,0 +1,28 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+#include "../../header/Element/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();
+        };
+    }
+}

Space-Invaders/Header/Element/Bunker/BunkerModel.h

@@ -0,0 +1,15 @@
+#pragma once
+#include <SFML/System/Vector2.hpp>
+
+namespace Element
+{
+	namespace Bunker
+	{
+		struct BunkerData
+		{
+			sf::Vector2f position;
+			BunkerData();
+			BunkerData(sf::Vector2f position);
+		};
+	}
+}

Space-Invaders/Header/Element/Bunker/BunkerView.h

@@ -0,0 +1,36 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+
+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;
+
+            //const sf::String bunker_texture_path = "assets/textures/bunker.png";
+
+            void scaleSprite();
+            void initializeImage();
+
+        public:
+            BunkerView();
+            ~BunkerView();
+
+            void initialize(BunkerController* controller);
+            void update();
+            void render();
+        };
+    }
+}

Space-Invaders/Header/Element/ElementService.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <vector>
+#include <SFML/System/Vector2.hpp>
+#include "../../header/Element/Bunker/BunkerController.h"
+#include "../../header/Element/Bunker/BunkerModel.h"
+
+namespace Element
+{
+	class BunkerController;
+
+	class ElementService
+	{
+	private:
+		//const vector so that the default values will not be changed down the road by mistake.
+		const std::vector<Bunker::BunkerData> bunker_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.0f, 800.f)),
+																Bunker::BunkerData(sf::Vector2f(1730.0f, 800.f)) };
+
+		std::vector<Bunker::BunkerController*> bunker_list;
+
+		void destroy();
+
+	public:
+		ElementService();
+		virtual ~ElementService();
+
+		void initialize();
+		void update();
+		void render();
+	};
+}

Space-Invaders/Header/Enemy/Controllers/SubZeroController.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "../../header/Enemy/EnemyController.h"
+
+namespace Enemy
+{
+    namespace Controller
+    {
+        class SubzeroController : public EnemyController
+        {
+        private:
+
+            float vertical_movement_speed = 100.f;
+
+            void move() override;
+            void moveDown();
+
+        public:
+
+            SubzeroController(EnemyType type);
+            ~SubzeroController();
+
+            void initialize() override;
+
+        };
+    }
+}

Space-Invaders/Header/Enemy/Controllers/ZapperController.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "../../header/Enemy/EnemyController.h"
+
+namespace Enemy
+{
+    namespace Controller
+    {
+        class ZapperController : public EnemyController
+        {
+        private:
+
+            float vertical_travel_distance = 100.f;
+
+            void move() override;
+            void moveLeft();
+            void moveRight();
+            void moveDown();
+
+        public:
+
+            ZapperController(EnemyType type);
+            ~ZapperController();
+
+            void initialize() override;
+
+        };
+    }
+}

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,
+    };
+}

Space-Invaders/Header/Enemy/EnemyController.h

@@ -0,0 +1,37 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+
+namespace Enemy
+{
+    class EnemyView;
+    class EnemyModel;
+
+    enum class EnemyType;
+    enum class EnemyState;
+
+    class EnemyController
+    {
+
+    protected:
+
+        EnemyView* enemy_view;
+        EnemyModel* enemy_model;
+
+        virtual void move() = 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();
+    };
+}

Space-Invaders/Header/Enemy/EnemyModel.h

@@ -0,0 +1,45 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+
+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:
+        EnemyModel(EnemyType type);
+        ~EnemyModel();
+
+        //const settings for enemy
+        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 float vertical_travel_distance = 100.f;
+        const float enemy_movement_speed = 250.0f;
+
+        void initialize();
+
+        // Getters and Setters
+        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);
+    };
+}

Space-Invaders/Header/Enemy/EnemyService.h

@@ -0,0 +1,35 @@
+#pragma once
+#include <vector>
+
+namespace Enemy
+{
+	class EnemyController;
+	enum class EnemyType;
+
+	class EnemyService
+	{
+	private:
+
+		const float spawn_interval = 2.f;
+
+		std::vector<EnemyController*> enemy_list;
+		float spawn_timer;
+
+		void updateSpawnTimer();
+		void processEnemySpawn();
+		EnemyType getRandomEnemyType();
+		EnemyController* createEnemy(EnemyType enemy_type);
+		void destroy();
+
+	public:
+		EnemyService();
+		~EnemyService();
+
+		void initialize();
+		void update();
+		void render();
+
+		EnemyController* spawnEnemy(); 		// Function to spawn enemy
+		void destroyEnemy(EnemyController* enemy_controller);
+	};
+}

Space-Invaders/Header/Enemy/EnemyView.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <SFML/Graphics.hpp>
+#include "../../Header/Enemy/EnemyConfig.h"
+
+namespace Enemy
+{
+    class EnemyController;
+
+    class EnemyView
+    {
+    private:
+        //const sf::String subzero_texture_path = "assets/textures/subzero.png";
+        //const sf::String zapper_texture_path = "assets/textures/zapper.png";
+
+        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();
+    };
+}