Feature 10 collisions

Space-Invaders/Header/Bullet/BulletConfig.h

@@ -0,0 +1,28 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+
+namespace Bullet
+{
+	enum class BulletType
+	{
+		LASER_BULLET,
+		TORPEDO,
+		FROST_BULLET,
+	};
+
+	enum class MovementDirection
+	{
+		UP,
+		DOWN,
+	};
+
+	class BulletConfig
+	{
+	public:
+		static const sf::String laser_bullet_texture_path;
+		static const sf::String torpedoe_texture_path;
+		static const sf::String frost_beam_texture_path;
+
+		static sf::String getBulletTexturePath(BulletType bullet_type);
+	};
+}

Space-Invaders/Header/Bullet/BulletController.h

@@ -0,0 +1,47 @@
+#pragma once
+#include"../../Header/Projectile/IProjectile.h"
+#include"../../Header/Bullet/BulletConfig.h"
+#include"../../Header/Entity/EntityConfig.h"
+#include"../../Header/Collision/ICollider.h"
+
+namespace Bullet
+{
+	class BulletView;
+	class BulletModel;
+
+	enum class BulletType;
+
+	class BulletController :public Projectile::IProjectile,public Collision::ICollider
+	{
+	protected:
+		BulletView* bullet_view;
+		BulletModel* bullet_model;
+
+		void updateProjectilePosition() override;
+
+		void processBulletCollision(ICollider* other_collider);
+		void processEnemyCollision(ICollider* other_collider);
+		void processPlayerCollision(ICollider* other_collider);
+		void processBunkerCollision(ICollider* other_collider);
+
+		void moveUP();
+		void moveDown();
+		void handleOutOfBounds();
+
+	public:
+		BulletController(BulletType bullet_type,Entity::EntityType owner_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();
+
+		Entity::EntityType getOwnerEntityType();
+
+		const sf::Sprite& getColliderSprite() override;
+		void onCollision(ICollider* other_collider) override;
+	};
+}

Space-Invaders/Header/Bullet/BulletModel.h

@@ -0,0 +1,38 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+#include"../../Header/Entity/EntityConfig.h"
+
+namespace Bullet
+{
+	enum class BulletType;
+	enum class MovementDirection;
+
+	class BulletModel
+	{
+	private:
+		float movement_speed = 300.f;
+		sf::Vector2f bullet_position;
+
+		BulletType bullet_type;
+		Entity::EntityType owner_type;
+		MovementDirection movement_direction;
+
+	public:
+		BulletModel(BulletType bullet_type, Entity::EntityType owner_type);
+		~BulletModel();
+
+		void initialize(sf::Vector2f position, MovementDirection direction);
+
+		sf::Vector2f getBulletPosition();
+		void setBulletPosition(sf::Vector2f position);
+
+		BulletType getBulletType();
+		Entity::EntityType getOwnerEntityType();
+
+		MovementDirection getMovementDirection();
+		void setMovementDirection(MovementDirection direction);
+
+		float getMovementSpeed();
+		void setMovementSpeed(float speed);
+	};
+}

Space-Invaders/Header/Bullet/BulletService.h

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

Space-Invaders/Header/Bullet/BulletView.h

@@ -0,0 +1,34 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+#include "../../Header/UI/UIElement/ImageView.h"
+
+namespace Bullet
+{
+	class BulletController;
+
+	class BulletView
+	{
+	private:
+		const float bullet_sprite_width = 18.f;
+		const float bullet_sprite_height = 18.f;
+
+		BulletController* bullet_controller;
+		UI::UIElement::ImageView* bullet_image;
+
+		void initializeImage();
+		void createUIElements();
+		sf::String getBulletTexturePath();
+
+		void destroy();
+
+	public:
+		BulletView();
+		~BulletView();
+
+		void initialize(BulletController* controller);
+		void update();
+		void render();
+
+		const sf::Sprite& getBulletSprite();
+	};
+}

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 bullet_type, Entity::EntityType owner_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 bullet_type, Entity::EntityType owner_type);
+			~LaserBulletController();
+
+			void initialize(sf::Vector2f position, MovementDirection)override;
+		};
+	}
+}

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 bullet_type,Entity::EntityType owner_type);
+			~TorpedoController();
+
+			void initialize(sf::Vector2f position, MovementDirection direction)override;
+		};
+	}
+}

Space-Invaders/Header/Collectible/ICollectible.h

@@ -0,0 +1,19 @@
+#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/Collision/CollisionService.h

@@ -0,0 +1,28 @@
+#pragma once
+#include<vector>
+
+namespace Collision
+{
+	class ICollider;
+
+	class CollisionService
+	{
+	private:
+		std::vector<ICollider*> collider_list;
+
+		void processCollision();
+		void doCollision(int index_i, int index_j);
+		bool hasCollisionOccured(int index_i, int index_j);
+		bool areActiveColliders(int index_i, int index_j);
+
+	public:
+		CollisionService();
+		~CollisionService();
+
+		void initialize();
+		void update();
+
+		void addCollider(ICollider* collider);
+		void removeCollider(ICollider* collider);
+	};
+}

Space-Invaders/Header/Collision/ICollider.h

@@ -0,0 +1,28 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+
+namespace Collision
+{
+	enum class CollisionState
+	{
+		ENABLED,
+		DISABLED,
+	};
+
+	class ICollider
+	{
+	private:
+		CollisionState collision_state;
+
+	public:
+		ICollider();
+		virtual ~ICollider();
+
+		virtual const sf::Sprite& getColliderSprite() = 0;
+		virtual void onCollision(ICollider* other_collider) = 0;
+
+		void enableCollision();
+		void disableCollision();
+		CollisionState getCollisionState();
+	};
+}

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

@@ -0,0 +1,33 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+#include"../../Header/Elements/Bunker/BunkerModel.h"
+#include"../../Header/Collision/ICollider.h"
+
+namespace Element
+{
+	namespace Bunker
+	{
+		class BunkerView;
+
+		class BunkerController : public Collision::ICollider
+		{
+		private:
+			BunkerView* bunker_view;
+			BunkerData bunker_data;
+
+		public:
+			BunkerController();
+			~BunkerController();
+
+			void initialize(BunkerData data);
+			void update();
+			void render();
+
+			sf::Vector2f getBunkerPosition();
+
+			const sf::Sprite& getColliderSprite() override;
+			void onCollision(ICollider* other_collider) override;
+		};
+	}
+
+}

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

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