Feature 4 main menu

Space-Invaders/Header/Event/EventService.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <SFML/Graphics/RenderWindow.hpp>
+#include <SFML/Window/Event.hpp>
+
+namespace Event
+{
+	enum class ButtonState
+	{
+		PRESSED,
+		HELD,
+		RELEASED,
+	};
+
+	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
+
+		//Button States
+		ButtonState left_mouse_button_state;
+		ButtonState right_mouse_button_state;
+		ButtonState left_arrow_button_state;
+		ButtonState right_arrow_button_state;
+		ButtonState A_button_state;
+		ButtonState D_button_state;
+
+		//Button and mouse state functions
+		void updateMouseButtonsState(ButtonState& current_button_state, sf::Mouse::Button mouse_button);
+		void updateKeyboardButtonsState(ButtonState& current_button_state, sf::Keyboard::Key keyboard_button);
+
+
+	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();
+		bool pressedLeftMouseButton(); // Mouse inputs for the player
+		bool pressedRightMouseButton();
+		bool pressedAKey(); // AD held check
+		bool pressedDKey();
+
+	};
+}
+

Space-Invaders/Header/Global/ServiceLocator.h

@@ -0,0 +1,47 @@
+#pragma once
+#include "../../Header/Graphic/GraphicService.h"
+#include "../../Header/Event/EventService.h"
+#include "../../Header/Player/PlayerService.h"
+#include "../../Header/Time/TimeService.h"
+#include "../../Header/UI/UIService.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;
+        UI::UIService* ui_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
+        UI::UIService* getUIService(); // Retrive the UIService 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 = 1920;
+		const int game_window_height = 1080;
+
+		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,42 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+#include "../../header/Global/ServiceLocator.h"
+
+namespace Main
+{
+	enum class GameState
+	{
+		BOOT,
+		MAIN_MENU,
+		GAMEPLAY,
+	};
+
+	class ServiceLocator;
+
+	class GameService
+	{
+	private:
+
+		static GameState current_state;
+
+		Global::ServiceLocator* service_locator;
+		sf::RenderWindow* game_window;
+
+
+		void initialize();		// Handles game initialization.
+		void initializeVariables();// Handles game initialization.
+		void destroy();			// Handles cleanup tasks.
+		void showMainMenu();
+
+	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.
+		static void setGameState(GameState new_state);
+		static GameState getGameState();
+	};
+}

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(950.f, 950.f);
+
+        sf::Vector2f player_position;
+        PlayerState player_state; //Declaration
+        int player_score;
+
+    public:
+        const sf::Vector2f left_most_position = sf::Vector2f(50.f, 950.f);
+        const sf::Vector2f right_most_position = sf::Vector2f(1800.f, 950.f);
+
+        const float player_movement_speed = 600.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();
+	};
+}
+