Feature 5 enemies

Space-Invaders/ENEMY/Controllers/SubZeroController.H

@@ -0,0 +1,12 @@
+#pragma once
+#include"../../ENEMY/EnemyController.h"
+namespace Enemy{
+	namespace controller {
+
+		class  SubzeroController : public  EnemyController {
+
+		private:
+		};
+	}
+
+}

Space-Invaders/ENEMY/Controllers/SubZeroController.cpp

@@ -0,0 +1,6 @@
+#include"../Controllers/SubZeroController.H"
+namespace Enmey {
+	namespace controller {
+
+	}
+}

Space-Invaders/ENEMY/Controllers/ZapperController.cpp

@@ -0,0 +1,7 @@
+#include"../Controllers/ZapperController.h"
+
+namespace Enemy {
+	namespace controller {
+
+	}
+}

Space-Invaders/ENEMY/Controllers/ZapperController.h

@@ -0,0 +1,10 @@
+#pragma once
+#include"../../ENEMY/EnemyController.h"
+namespace Enemy {
+	namespace controller {
+		class ZapperController : public EnemyController {
+
+		private:
+		};
+	}
+}

Space-Invaders/ENEMY/EnemyConfig.h

@@ -0,0 +1 @@
+#pragma once

Space-Invaders/Enemy/EnemyController.cpp

@@ -0,0 +1,109 @@
+#include "EnemyController.h"
+#include"../../ENEMY/EnemyModel.h"
+#include"../../ENEMY/EnemyView.h"
+#include"../../Headers/Global/ServiceLocator.h"
+#include<iostream>
+namespace Enemy {
+	using namespace std;
+	using namespace Global;
+	EnemyController::EnemyController()
+	{
+		enemy_view = new EnemyView();
+		enemy_model = new EnemyModel();
+
+	}
+	EnemyController::~EnemyController()
+	{
+		delete (enemy_view);
+		delete (enemy_model);
+	}
+	void Enemy::EnemyController::initialize()
+	{
+		enemy_model->initialize();
+		enemy_view->initialize(this); // we will discuss this soo
+	}
+
+	void Enemy::EnemyController::update()
+	{
+		move();
+		enemy_view->update();
+	}
+
+	void Enemy::EnemyController::render()
+	{
+		enemy_view->render();
+	}
+	sf::Vector2f EnemyController::getEnemyPosition()
+	{
+		return enemy_model->getEnemyPosition();
+
+	}
+	void EnemyController::move()
+	{
+		switch (enemy_model->getmovementdirection())
+		{
+		case MovementDirection::LEFT:
+			moveLeft();
+			break;
+		case MovementDirection::RIGHT:
+			moveRight();
+			break;
+		case MovementDirection::DOWN:
+			moveDown();
+			break;
+		}
+
+	}
+	void EnemyController::moveLeft()
+	{
+		sf::Vector2f currentposition = enemy_model->getEnemyPosition();
+		currentposition.x -= enemy_model->movement_speed * ServiceLocator::getInstance()->gettimeservice()->getdeltatime();
+		if (currentposition.x <= enemy_model->left_most.x) {
+			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->movement_speed * ServiceLocator::getInstance()->gettimeservice()->getdeltatime();
+		if (currentposition.x >= enemy_model->right_most.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->movement_speed * ServiceLocator::getInstance()->gettimeservice()->getdeltatime();
+
+		//check if enemy has moved the specified distance downwards
+		if (currentPosition.y >= enemy_model->getReferencePosition().y + enemy_model->downward_distance)
+		{
+
+			if (enemy_model->getReferencePosition().x >= enemy_model->right_most.x) {
+
+				enemy_model->setmovementdirection(MovementDirection::LEFT);
+				cout << "call left";
+			}
+			else {
+
+				enemy_model->setmovementdirection(MovementDirection::RIGHT);
+			}
+
+
+		}
+		else {
+			enemy_model->setEnemyPosition(currentPosition);
+		}
+
+
+	}
+}

Space-Invaders/Enemy/EnemyController.h

@@ -0,0 +1,26 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+ namespace Enemy {
+	 class EnemyView;
+	 class EnemyModel;
+	class EnemyController {
+	private:
+		EnemyView* enemy_view;
+		EnemyModel* enemy_model;
+
+	public:
+
+		EnemyController();
+		~EnemyController();
+
+		void initialize();
+		void update();
+		void render();
+		sf::Vector2f getEnemyPosition();
+
+		void move();
+		void moveLeft();
+		void moveRight();
+		void moveDown();
+	};
+}

Space-Invaders/Enemy/EnemyModel.cpp

@@ -0,0 +1,46 @@
+#include "EnemyModel.h"
+namespace Enemy {
+	Enemy::EnemyModel::EnemyModel()
+	{
+
+	}
+
+	Enemy::EnemyModel::~EnemyModel()
+	{
+		enemy_position = reference_position;
+	}
+
+	void Enemy::EnemyModel::initialize()
+	{
+		movement_direction = MovementDirection::RIGHT;
+		enemy_position = reference_position;
+	}
+
+	sf::Vector2f Enemy::EnemyModel::getEnemyPosition()
+	{
+		return enemy_position;
+	}
+
+	void Enemy::EnemyModel::setEnemyPosition(sf::Vector2f position)
+	{
+		enemy_position = position;
+	}
+
+	sf::Vector2f Enemy::EnemyModel::getReferencePosition()
+	{
+		return reference_position;
+	}
+
+	void Enemy::EnemyModel::setReferencePosition(sf::Vector2f position)
+	{
+		reference_position = position;
+	}
+	MovementDirection EnemyModel::getmovementdirection()
+	{
+		return movement_direction;
+	}
+	void EnemyModel::setmovementdirection(MovementDirection direction)
+	{
+		movement_direction = direction;
+	}
+}

Space-Invaders/Enemy/EnemyModel.h

@@ -0,0 +1,44 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+namespace Enemy {
+    enum class MovementDirection {
+
+        RIGHT,
+        LEFT,
+        DOWN,
+    };
+
+	class EnemyModel {
+
+    private:
+
+        MovementDirection movement_direction;
+
+
+    public:
+        EnemyModel();
+        ~EnemyModel();
+
+
+        sf::Vector2f reference_position = sf::Vector2f(50.f, 50.f);
+        sf::Vector2f enemy_position;
+
+       const float movement_speed = 250.f;
+        const sf::Vector2f right_most = sf::Vector2f(1800.f, 950.f);
+        const sf::Vector2f left_most = sf::Vector2f(50.f, 950.f);
+        float downward_distance = 100.f;
+
+        void initialize();
+
+        sf::Vector2f getEnemyPosition();
+        void setEnemyPosition(sf::Vector2f position);
+
+        sf::Vector2f getReferencePosition();
+        void setReferencePosition(sf::Vector2f position);
+
+        MovementDirection getmovementdirection();
+        void setmovementdirection(MovementDirection direction);
+
+
+	};
+}

Space-Invaders/Enemy/EnemyService.cpp

@@ -0,0 +1,62 @@
+//#include "../../Header/Enemy/EnemyService.h"
+//#include "../../Header/Enemy/EnemyController.h"
+//#include "../../Header/Global/ServiceLocator.h"
+//#include "../../Header/Time/TimeService.h"
+#include"../../ENEMY/Enemyservice.h"
+#include"../../ENEMY/EnemyController.h"
+#include"../../Headers/Global/ServiceLocator.h"
+#include"../../Headers/TIME/TimeService .h"
+
+namespace Enemy
+{
+	using namespace Global;
+
+	EnemyService::EnemyService() { }
+
+	EnemyService::~EnemyService() { destroy(); }
+
+	void EnemyService::initialize()
+	{
+		spawn_timer = spawn_interval; // for the first spawn
+	}
+
+	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(); // increase timer
+	}
+
+	void EnemyService::processEnemySpawn()
+	{
+		if (spawn_timer >= spawn_interval)
+		{
+			spawnEnemy(); //spawn 
+			spawn_timer = 0.0f; // reset
+		}
+	}
+
+	void EnemyService::spawnEnemy()
+	{
+		EnemyController* enemy_controller = new EnemyController(); // create
+		enemy_controller->initialize(); // init as soon as created
+
+		enemy_list.push_back(enemy_controller); //add to list
+	}
+
+	void EnemyService::destroy()
+	{
+		for (int i = 0; i < enemy_list.size(); i++) delete (enemy_list[i]); //delete all enemies
+	}
+}

Space-Invaders/Enemy/EnemyView.cpp

@@ -0,0 +1,49 @@
+#include "EnemyView.h"
+#include"../../Headers/Global/ServiceLocator.h"
+#include"../../Headers/Graphic/GraphicService.h"
+#include"../../ENEMY/EnemyController.h"
+namespace Enemy {
+	using namespace Global;
+	using namespace Graphic;
+	void Enemy::EnemyView::initializeEnemySprite()
+	{
+		if (enemy_texture.loadFromFile(enemy_texture_path)) //check if the texture loaded
+		{
+			enemy_sprite.setTexture(enemy_texture); //set the sprite
+			scaleEnemySprite(); // call the method to scale the sprite
+		}
+	}
+
+	void Enemy::EnemyView::scaleEnemySprite()
+	{
+		enemy_sprite.setScale(
+			static_cast<float>(enemy_sprite_width) / enemy_sprite.getTexture()->getSize().x,
+			static_cast<float>(enemy_sprite_height) / enemy_sprite.getTexture()->getSize().y
+		);
+	}
+
+	Enemy::EnemyView::EnemyView()
+	{
+	}
+
+	Enemy::EnemyView::~EnemyView()
+	{
+	}
+
+	void Enemy::EnemyView::initialize(EnemyController* controller)
+	{
+		enemy_controller = controller;
+		game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow();
+		initializeEnemySprite();
+	}
+
+	void Enemy::EnemyView::update()
+	{
+		enemy_sprite.setPosition(enemy_controller->getEnemyPosition());
+	}
+
+	void Enemy::EnemyView::render()
+	{
+		game_window->draw(enemy_sprite);
+	}
+}