Feature 11 animations

Space-Invaders/Header/AnimationSystem/AnimationService.h

@@ -0,0 +1,36 @@
+#pragma once
+#include <vector>
+#include <SFML/System/Vector2.hpp>
+#include "../../header/AnimationSystem/AnimationSystem.h"
+
+namespace Animation
+{
+	enum class AnimationType
+	{
+		EXPLOSION,
+	};
+
+	class AnimationService
+	{
+	private:
+		std::vector<AnimationSystem*> animation_system_list;
+		std::vector<AnimationSystem*> flagged_animation_system_list;
+
+		AnimationSystemConfig getAnimationSystemConfig(AnimationType animation_type);
+		void destroyFlaggedAnimationSystem();
+		void destroy();
+
+	public:
+		AnimationService();
+		virtual ~AnimationService();
+
+		void initialize();
+		void update();
+		void render();
+
+		void reset();
+
+		void spawnAnimationSystem(sf::Vector2f position, AnimationType animation_type);
+		void destroyAnimationSystem(AnimationSystem* animation_system);
+	};
+}

Space-Invaders/Header/AnimationSystem/AnimationSystem.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+#include "../../header/AnimationSystem/AnimationSystemConfig.h"
+#include "../../header/UI/UIElement/ImageView.h"
+
+namespace Animation
+{
+    class AnimationSystem
+    {
+    private:
+        AnimationSystemConfig animation_system_config;
+
+        sf::Vector2f animation_position;
+        UI::UIElement::ImageView* animation_image;
+
+        void createUIElements();
+        void initializeImage();
+
+        int current_frame;
+        sf::Clock clock;
+        sf::Time frame_time;
+
+    public:
+        AnimationSystem(AnimationSystemConfig config);
+        ~AnimationSystem();
+
+        void initialize(sf::Vector2f position);
+        void update();
+        void render();
+
+        void destroy();
+    };
+}

Space-Invaders/Header/AnimationSystem/AnimationSystemConfig.h

@@ -0,0 +1,30 @@
+#pragma once
+namespace Animation
+{
+    struct AnimationSystemConfig
+    {
+        sf::String Animation_texture_path;
+
+        float sprite_sheet_width;
+        float sprite_sheet_height;
+
+        //one frame of the sprite sheet - W x H
+        float tile_width;
+        float tile_height;
+
+        int number_of_animation_frames; //total frames
+        float frame_duration; //duration of a single frame - the amount to wait for next frame in the animation spritesheet
+
+        AnimationSystemConfig() = default; // Use default for default constructor
+
+        //this will allow us to initialize an animation with it's configuration.
+        AnimationSystemConfig(sf::String texture_path, float sprite_width, float sprite_height, float t_width, float t_height, int frames, float duration) :
+            Animation_texture_path(texture_path),
+            sprite_sheet_width(sprite_width),
+            sprite_sheet_height(sprite_height),
+            tile_width(t_width),
+            tile_height(t_height),
+            number_of_animation_frames(frames),
+            frame_duration(duration) {}
+    };
+}

Space-Invaders/Header/AnimationSystem/AnimationSystemConfigData.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "AnimationSystemConfig.h"
+#include "../../Header/Global/Config.h"
+
+namespace Animation
+{
+	const AnimationSystemConfig explosion_animation_config(Global::Config::explosion_texture_path, 70.0f, 80.0f, 14.28f, 20.0f, 7, 0.03f);
+}

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, //player needs to shoot in upward direction
+		DOWN, // enemies always shoot in downward direction
+	};
+
+	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,48 @@
+#pragma once
+#include "../../Header/Projectile/IProjectile.h"
+#include "../../Header/Entity/EntityConfig.h"
+#include "../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;
+
+        //Collision funcs
+        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 type, Entity::EntityType owner_type);
+        virtual ~BulletController();
+
+        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,40 @@
+#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 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,39 @@
+#pragma once
+#include <vector>
+#include "SFML/System/Vector2.hpp"
+#include "../../Header/Entity/EntityConfig.h"
+#include "../../Header/Projectile/IProjectile.h"
+
+namespace Bullet
+{
+	class BulletController;
+	enum class BulletType;
+	enum class MovementDirection;
+
+	class BulletService
+	{
+	private:
+
+		std::vector<Projectile::IProjectile*> flagged_bullet_list;
+		std::vector<Projectile::IProjectile*> bullet_list;
+
+		BulletController* createBullet(BulletType 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 type, sf::Vector2f position, MovementDirection direction, Entity::EntityType owner_type);
+		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 createUIElements();
+        void initializeImage();
+        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 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 type, Entity::EntityType owner_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, Entity::EntityType owner_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() {};
+	};
+}