Feature 8 powerups

Space-Invaders/Header/Bullet/BulletConfig.h

@@ -0,0 +1,16 @@
+#pragma once
+namespace Bullet
+{
+	enum class BulletType
+	{
+		LASER_BULLET,
+		TORPEDO,
+		FROST_BULLET,
+	};
+
+	enum class MovementDirection
+	{
+		UP, //player needs to shoot in upward direction
+		DOWN, // enemies always shoot in downward direction
+	};
+}

Space-Invaders/Header/Bullet/BulletController.h

@@ -0,0 +1,35 @@
+#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();
+    };
+}

Space-Invaders/Header/Bullet/BulletModel.h

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

Space-Invaders/Header/Bullet/BulletService.h

@@ -0,0 +1,32 @@
+#pragma once
+#include <vector>
+#include "SFML/System/Vector2.hpp"
+#include "../../Header/Projectile/IProjectile.h"
+
+namespace Bullet
+{
+	class BulletController;
+	enum class BulletType;
+	enum class MovementDirection;
+
+	class BulletService
+	{
+	private:
+
+		std::vector<Projectile::IProjectile*> bullet_list;
+
+		BulletController* createBullet(BulletType bullet_type);
+		void destroy();
+
+	public:
+		BulletService();
+		virtual ~BulletService();
+
+		void initialize();
+		void update();
+		void render();
+
+		BulletController* spawnBullet(BulletType bullet_type, sf::Vector2f position, MovementDirection direction);
+		void destroyBullet(BulletController* bullet_controller);
+	};
+}

Space-Invaders/Header/Bullet/BulletView.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+#include "../../Header/Bullet/BulletController.h"
+
+namespace Bullet
+{
+    class BulletController;
+    enum class BulletType;
+
+    class BulletView
+    {
+    private:
+        const float bullet_sprite_width = 18.f;
+        const float bullet_sprite_height = 18.f;
+
+        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();
+    };
+}

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 torpedo_movement_speed = 500.f;
+
+        public:
+            FrostBulletController(BulletType type);
+            ~FrostBulletController();
+
+            void initialize(sf::Vector2f position, MovementDirection direction) override;
+        };
+    }
+}

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 direction) override;
+        };
+    }
+}

Space-Invaders/Header/Bullet/Controllers/TorpedoController.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;
+        };
+    }
+}

Space-Invaders/Header/Collectible/ICollectible.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <SFML/System/Vector2.hpp>
+
+namespace Collectible
+{
+	class ICollectible
+	{
+	public:
+		virtual void onCollected() = 0;
+		virtual void initialize(sf::Vector2f position) = 0;
+		virtual void update() = 0;
+		virtual void render() = 0;
+		virtual sf::Vector2f getCollectiblePosition() = 0;
+
+		virtual ~ICollectible() {};
+	};
+}

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,30 @@
+#pragma once
+
+#include "../../header/Enemy/EnemyController.h"
+
+namespace Enemy
+{
+    namespace Controller
+    {
+        class SubzeroController : public EnemyController
+        {
+        private:
+
+            float vertical_movement_speed = 100.f;
+            const float subzero_rate_of_fire = 2.f;
+
+            void move() override;
+            void moveDown();
+
+            void fireBullet() override;
+
+        public:
+
+            SubzeroController(EnemyType type);
+            ~SubzeroController();
+
+            void initialize() override;
+
+        };
+    }
+}