Feature 1 level

Space-Invaders/Header/Event/EventService.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <SFML/Graphics/RenderWindow.hpp>
+#include <SFML/Window/Event.hpp>
+
+namespace Event
+{
+	class EventService
+	{
+	private:
+		sf::Event game_event; //event var
+		sf::RenderWindow* game_window; //ptr to our game window
+
+		bool isGameWindowOpen();
+		bool gameWindowWasClosed(); //for the condition we already had - the title bar cross.
+		bool hasQuitGame(); //for our new 'ESC' condition
+
+
+
+	public:
+		EventService();
+		~EventService();
+
+		void initialize();
+		void update();
+		void processEvents(); // while window is open we will check for events
+		bool pressedEscapeKey();
+		bool isKeyboardEvent();
+		bool pressedLeftKey(); // getting inputs for the player
+		bool pressedRightKey();
+
+	};
+}
+

Space-Invaders/Header/Global/ServiceLocator.h

@@ -0,0 +1,44 @@
+#pragma once
+#include "../../Header/Graphic/GraphicService.h"
+#include "../../Header/Event/EventService.h"
+#include "../../Header/Player/PlayerService.h"
+#include "../../Header/Time/TimeService.h"
+
+// ServiceLocator Class Summary: This class manages access to various services in the application.
+// include relevant headers files
+
+namespace Global
+{
+    class ServiceLocator
+    {
+    private:
+
+        // Private Attributes:
+        Graphics::GraphicService* graphic_service;
+        Event::EventService* event_service;
+        Player::PlayerService* player_service;
+        Time::TimeService* time_service;
+
+        // Public Methods
+        ServiceLocator();
+        ~ServiceLocator();
+
+        // Private Methods:
+        void createServices();
+        void clearAllServices();
+
+    public:
+
+        // Public Methods:
+        static ServiceLocator* getInstance();
+        void initialize(); 			//	Initializes the ServiceLocator.
+        void update(); 				//	Updates all services.
+        void render(); 				//	Renders using the services.
+
+        // Methods to Get Specific Services: 
+        Event::EventService* getEventService();   // Retrieve the EventService instance
+        Graphics::GraphicService* getGraphicService();   // Retrieve the GraphicService instance
+        Player::PlayerService* getPlayerService(); // Retrieve the PlayerService instance
+        Time::TimeService* getTimeService(); // Retrieve the TimeService instance
+    };
+}

Space-Invaders/Header/Graphic/GraphicService.h

@@ -0,0 +1,41 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+
+namespace Graphics
+{
+	class GraphicService
+	{
+	private:
+
+		const std::string game_window_title = "Alien Invader";
+
+		const int game_window_width = 800;
+		const int game_window_height = 600;
+
+		const int frame_rate = 60;
+
+		const sf::Color window_color = sf::Color::Black;
+
+		sf::VideoMode* video_mode; // ptr to video mode
+		sf::RenderWindow* game_window; // ptr to a RenderWindow
+
+		void setVideoMode(); // Method for setting our video mode
+		void onDestroy(); // method to run when window is deleted
+
+	public:
+		GraphicService();
+		~GraphicService(); //cleanup
+
+		//method to create the game window. returns a pointer to an instance of the game window
+		sf::RenderWindow* createGameWindow();
+
+
+		void initialize(); //lifecycle functions
+		void update(); //..
+		void render(); //..
+		bool isGameWindowOpen(); //check if the window is open
+
+		sf::RenderWindow* getGameWindow(); //getter for the game window instance
+		sf::Color getWindowColor();//get the color
+	};
+}

Space-Invaders/Header/Main/GameService.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+#include "../../header/Global/ServiceLocator.h"
+
+namespace Main
+{
+	class ServiceLocator;
+
+	class GameService
+	{
+	private:
+
+		Global::ServiceLocator* service_locator;
+		sf::RenderWindow* game_window;
+
+
+		void initialize();		// Handles game initialization.
+		void initializeVariables();// Handles game initialization.
+		void destroy();			// Handles cleanup tasks.
+
+	public:
+		GameService();			// Constructor for initializing the GameService object.
+		~GameService();	        // Destructor for cleaning up resources upon object deletion.
+
+		void ignite();			// Initiates the game.
+		void update();			// Updates the game logic and game state.
+		void render();			// Renders each frame of the game.
+		bool isRunning();		// Checks if the game is currently running.
+	};
+}

Space-Invaders/Header/Player/PlayerController.h

@@ -0,0 +1,31 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+
+namespace Player
+{
+    class PlayerView;
+    class PlayerModel;
+    enum class PlayerState;
+
+    class PlayerController
+    {
+    private:
+
+        PlayerView* player_view;
+        PlayerModel* player_model;
+
+        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,46 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+
+namespace Player
+{
+    enum class PlayerState //Our Enum
+    {
+        ALIVE,
+        DEAD,
+        // we will add more states later
+    };
+
+    class PlayerModel
+    {
+    private:
+        const sf::Vector2f initial_player_position = sf::Vector2f(400.f, 400.f);
+
+        sf::Vector2f player_position;
+        PlayerState player_state; //Declaration
+        int player_score;
+
+    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 player_movement_speed = 300.0f;
+
+        PlayerModel();
+        ~PlayerModel();
+
+        void initialize();
+        void reset();
+
+        sf::Vector2f getPlayerPosition();
+        void setPlayerPosition(sf::Vector2f position);
+
+        int getPlayerScore();
+        void setPlayerScore(int score);
+
+        //new getter and setter
+        PlayerState getPlayerState();
+        void setPlayerState(PlayerState state);
+
+
+    };
+}

Space-Invaders/Header/Player/PlayerService.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "../../Header/Player/PlayerController.h"
+
+namespace Player
+{
+	class PlayerService
+	{
+	private:
+		PlayerController* player_controller;
+
+	public:
+		PlayerService();
+		~PlayerService();
+
+		void initialize();
+		void update();
+		void render();
+	};
+}

Space-Invaders/Header/Player/PlayerView.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+#include "../../Header/Player/PlayerController.h"
+
+namespace Player
+{
+    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;
+
+        sf::RenderWindow* game_window;
+
+        sf::Texture player_texture;
+        sf::Sprite player_sprite;
+
+        void initializePlayerSprite();
+        void scalePlayerSprite();
+
+        PlayerController* player_controller; // ptr to player controller
+
+    public:
+        PlayerView();
+        ~PlayerView();
+
+        void initialize();
+        void update();
+        void render();
+        void initialize(PlayerController* controller);
+    };
+}

Space-Invaders/Header/Time/TimeService.h

@@ -0,0 +1,32 @@
+#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.
+
+namespace 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;
+
+		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,51 @@
+#include "../../Header/Event/EventService.h"
+#include "../../Header/Main/GameService.h"
+#include "../../Header/Graphic/GraphicService.h"
+#include "../../Header/Global/ServiceLocator.h"
+
+namespace Event
+{
+
+    EventService::EventService() { game_window = nullptr; }
+
+    EventService::~EventService() = default; //calls the default destructor
+
+    using namespace Global;
+
+    void EventService::initialize()
+    {
+        game_window = ServiceLocator::getInstance()->getGraphicService()->getGameWindow();
+    }
+
+    void EventService::update()
+    {
+        //for later
+    }
+
+    void EventService::processEvents()
+    {
+        if (isGameWindowOpen()) {
+            while (game_window->pollEvent(game_event)) {
+                // Check for window closure
+                if (gameWindowWasClosed() || hasQuitGame())
+                {
+                    game_window->close();
+                }
+            }
+        }
+    }
+
+    bool EventService::hasQuitGame() { return (isKeyboardEvent() && pressedEscapeKey()); } // only true if the ESC key is pressed and a keyboard event has been registered
+
+    //checks for if a keyboard key has been pressed
+    bool EventService::isKeyboardEvent() { return game_event.type == sf::Event::KeyPressed; }
+
+    //control click on the SFML functions to see what they do internally
+    bool EventService::pressedEscapeKey() { return game_event.key.code == sf::Keyboard::Escape; }
+    bool EventService::isGameWindowOpen() { return game_window != nullptr; }
+    bool EventService::gameWindowWasClosed() { return game_event.type == sf::Event::Closed; }
+
+    // Player inputs 
+    bool EventService::pressedLeftKey() { return game_event.key.code == sf::Keyboard::Left; }
+    bool EventService::pressedRightKey() { return game_event.key.code == sf::Keyboard::Right; }
+}