Feature 3 player ship

Space-Invaders/Header/Event/EventService.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <SFML/Graphics/RenderWindow.hpp>
+#include <SFML/Window/Event.hpp>
+
+class EventService
+{
+private:
+	sf::Event gameEvent;
+	sf::RenderWindow* gameWindow;
+
+	bool isGameWindowOpen();
+	bool gameWindowWasClosed();
+	bool hasQuitGame();
+
+
+public:
+	EventService();
+	~EventService();
+
+
+
+	void Initialize();
+	void Update();
+	void ProcessEvents();
+	bool PressedEscapeKey();
+	bool isKeyboardEvent();
+
+	bool pressedLeftKey();
+	bool pressedRightKey();
+};

Space-Invaders/Header/Global/ServiceLocator.h

@@ -0,0 +1,36 @@
+#pragma once
+#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\Graphic\GraphicService.h"
+#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\Event\EventService.h"
+#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\Player\PlayerService.h"
+#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\Time\TimeService.h"
+
+class ServiceLocator
+{
+private:
+
+
+	GraphicService *graphicService;
+	EventService* eventService;
+	PlayerService* playerService;
+	TimeService* timeService;
+
+	ServiceLocator();
+	~ServiceLocator();
+
+	void CreateServices();
+	void ClearAllServices();
+
+public:
+	static ServiceLocator* GetInstance();
+
+	void Initialize();
+	void Update();
+	void Render();
+
+	GraphicService* getGraphicService();
+	EventService* getEventService();
+	PlayerService* getPlayerService();
+	TimeService* getTimeService();
+
+
+};

Space-Invaders/Header/Graphic/GraphicService.h

@@ -0,0 +1,39 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+
+class GraphicService
+{
+private:
+	const std::string gameWindowTitle = "Space Invaders";
+
+
+	const int gameWindowWidth = 800;
+	const int gameWindowHeight = 600;
+
+	const sf::Color windowColor = sf::Color::Blue;
+
+	const int frameRate=60;
+
+	sf::VideoMode* videoMode;
+	sf::RenderWindow* gameWindow;
+	void setVideoMode(); // Method for setting our video mode
+	void onDestroy(); // method to run when window is deleted
+
+
+public:
+
+	GraphicService();
+	~GraphicService();
+	sf::RenderWindow* CreateGameWindow();
+
+
+	void Initialize();
+	void Update();
+	void Render();
+	bool isGameWindowOpen();
+
+
+	sf::RenderWindow* GetGameWindow();
+	sf::Color getWindowColor();
+
+};

Space-Invaders/Header/Main/GameService.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <SFML/Graphics.hpp>
+#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\Global\ServiceLocator.h"
+class GameService
+{
+private:
+	ServiceLocator* serviceLocator;
+	sf::RenderWindow* gameWindow;
+
+
+
+	void Initialize(); //initialize the game
+	void InitializeVariables();
+	void Destroy();  //cleanup of resources
+
+
+public:
+	GameService(); //construtor for initializing game service object
+	~GameService(); //destrutor for cleaning up the resources
+
+ 	void Ignite();  //Start the game
+	void Update();   //Updates Game logic and states
+	void Render();  //Render things on Screen
+	bool IsGameRunning(); //checks if game is running
+
+
+
+
+};

Space-Invaders/Header/Player/PlayerController.h

@@ -0,0 +1,32 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+//#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\PlayerModel.h"
+//#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\PlayerView.h"
+
+enum class PlayerState;
+class PlayerView;
+class PlayerModel;
+class PlayerController
+{
+private:
+	PlayerModel* playerModel;
+	PlayerView* playerView;
+
+	void processPlayerInput();
+
+
+	void moveLeft();
+	void moveRight();
+
+public:
+	PlayerController();
+	~PlayerController();
+
+	void initialize();
+	void update();
+	void render();
+
+	sf::Vector2f getPlayerPosition();
+
+
+};

Space-Invaders/Header/Player/PlayerModel.h

@@ -0,0 +1,42 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+enum class PlayerState {
+	ALIVE,
+	DEAD,
+};
+class PlayerModel
+{
+private:
+	const sf::Vector2f initialPlayerPosition = sf::Vector2f(500.0f, 500.0f); //new Var
+	sf::Vector2f playerPosition;
+	bool playerAlive;
+	int playerScore = 0;
+	PlayerState playerState;
+
+
+
+public:
+
+
+	const sf::Vector2f left_most_position = sf::Vector2f(50.f, 0.f);
+	const sf::Vector2f right_most_position = sf::Vector2f(700.f, 0.f);
+	const float playerMovementSpeed = 200.0f;
+	PlayerModel();
+	~PlayerModel();
+
+	void Initialize();
+	void Reset();
+
+
+	//getters and setters
+	sf::Vector2f getPlayerPosition();
+	void setPlayerPosition(sf::Vector2f position);
+
+
+	int getPlayerScore();
+	void setPlayerScore(int score);
+	PlayerState getPlayerState();
+	void setPlayerState(PlayerState state);
+
+
+};

Space-Invaders/Header/Player/PlayerService.h

@@ -0,0 +1,18 @@
+#pragma once
+
+
+class PlayerController;
+
+class PlayerService
+{
+private:
+	PlayerController* playerController;
+
+public:
+	PlayerService();
+	~PlayerService();
+
+	void initialize();
+	void update();
+	void render();
+};

Space-Invaders/Header/Player/PlayerView.h

@@ -0,0 +1,32 @@
+#pragma once
+#include<SFML/Graphics.hpp>
+//#include "../../Header/Player/PlayerController.h"
+
+class PlayerController;
+
+class PlayerView {
+private:
+	const sf::String player_texture_path = "assets/textures/player_ship.png";
+	const float player_sprite_width = 60.f;
+	const float player_sprite_height = 60.f;
+	PlayerController* player_controller;
+
+	sf::RenderWindow* game_window;
+
+	sf::Texture player_texture;
+	sf::Sprite player_sprite;
+
+
+	void initializePlayerSprite();
+	void scaleSprite();
+
+public:
+	PlayerView();
+	~PlayerView();
+
+	void Initialise(PlayerController* controller);
+	void Update();
+	void Render();
+
+
+};

Space-Invaders/Header/Time/TimeService.h

@@ -0,0 +1,31 @@
+#pragma once
+#include <chrono>
+
+/*
+	// The TimeService class helps keep track of time in game and calculate delta time.
+	// Utilizes the <chrono> library to calculate delta time.
+	*/
+class TimeService
+{
+private:
+
+	// A point in time which indicates the starting time of previous frame.
+	std::chrono::time_point<std::chrono::steady_clock> previous_time;
+	// No need to worry about the syntax of this variable too much right now
+	// It'll be explained in detail at a later time.
+
+	float delta_time; //to store the detla time
+
+	void updateDeltaTime(); // method to update time
+	float calculateDeltaTime(); //calculate time by subtracting the previous time from the current time
+	void updatePreviousTime(); // finally update the current time to be previous time
+
+public:
+
+	//lifecycle methods
+	void initialize();
+	void update();
+
+	//getter
+	float getDeltaTime();
+};

Space-Invaders/Source/Event/EventService.cpp

@@ -0,0 +1,88 @@
+#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\Event\EventService.h"
+#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\Main\GameService.h"
+#include "D:\Outscal\Space-Invaders\Space-Invaders\Header\Graphic\GraphicService.h"
+
+
+EventService::EventService()
+{
+    gameWindow = nullptr;
+}
+
+EventService::~EventService() = default;
+
+void EventService::Initialize()
+{
+    gameWindow = ServiceLocator::GetInstance()->getGraphicService()->GetGameWindow();
+
+}
+
+void EventService::Update()
+{
+
+
+}
+
+void EventService::ProcessEvents()
+{
+    if (isGameWindowOpen())
+    {
+        while (gameWindow->pollEvent(gameEvent))
+        {
+            if (gameWindowWasClosed() || hasQuitGame())
+            {
+
+                gameWindow->close();
+            }
+        }
+    }
+
+
+}
+
+bool EventService::hasQuitGame()
+{
+    return (isKeyboardEvent() && PressedEscapeKey());
+}
+
+bool EventService::isKeyboardEvent()
+{
+    return gameEvent.type ==  sf::Event::KeyPressed;
+}
+
+bool EventService::PressedEscapeKey()
+{
+    return gameEvent.key.code == sf::Keyboard::Escape;
+}
+
+bool EventService::isGameWindowOpen()
+{
+    return gameWindow != nullptr;
+}
+
+bool EventService::gameWindowWasClosed()
+{
+    return gameEvent.type == sf::Event::Closed;
+
+}
+
+bool EventService::pressedLeftKey()
+{
+    return gameEvent.key.code == sf::Keyboard::Left;
+}
+
+bool EventService::pressedRightKey()
+{
+    return gameEvent.key.code == sf::Keyboard::Right;
+}
+
+
+
+
+
+
+
+
+
+
+
+