Implemented Finite State Machine

.gitignore

@@ -5,7 +5,6 @@ gmon.out
 *.stats
 Thumbs.db
 .DS_Store
-PCH.hpp
 
 # VS Code
 .vscode/ipch

.vscode/c_cpp_properties.json

@@ -29,8 +29,7 @@
 			],
 			"includePath": [
 				"${workspaceFolder}/src",
-				"${workspaceFolder}/lib",
-				"/usr/local/include/**"
+				"${workspaceFolder}/lib"
 			],
 			"defines": [
 				"_DEBUG"

.vscode/settings.json

@@ -85,9 +85,33 @@
 		"streambuf": "cpp",
 		"thread": "cpp",
 		"typeinfo": "cpp",
-		"variant": "cpp"
+		"variant": "cpp",
+		"__bit_reference": "cpp",
+		"__bits": "cpp",
+		"__config": "cpp",
+		"__debug": "cpp",
+		"__errc": "cpp",
+		"__functional_base": "cpp",
+		"__hash_table": "cpp",
+		"__locale": "cpp",
+		"__mutex_base": "cpp",
+		"__node_handle": "cpp",
+		"__nullptr": "cpp",
+		"__split_buffer": "cpp",
+		"__string": "cpp",
+		"__threading_support": "cpp",
+		"__tree": "cpp",
+		"__tuple": "cpp",
+		"bit": "cpp",
+		"complex": "cpp",
+		"ios": "cpp",
+		"locale": "cpp",
+		"stack": "cpp",
+		"__availability": "cpp"
+	},
+	"terminal.integrated.automationProfile.windows": {
+		"path": "C:/Program Files/Git/bin/bash.exe",
 	},
-	"terminal.integrated.automationShell.windows": "C:/Program Files/Git/bin/bash.exe",
 	"terminal.integrated.env.windows": {
 		"Path": "C:/mingw32/bin;C:/SFML-2.5.1/bin"
 	},

docs/Window FSM.md

@@ -0,0 +1,72 @@
+# Window Finite State Machine
+
+To make the game engine usable and scalable, there needed to be the option to split functionality into different pages and files, such as the menu and the game itself. Therefore a **finite state machine** (hereafter FSM) is needed to keep track of what state the program is currently in and to provide methods of transitioning from different states.
+
+The primary logic for the FSM is held in the `main.cpp` file as it runs the main game loop and the high-level process of the program. This file has two main functions: **the gameloop** & **the stateloop**. Below shows some code for the gameloop:
+
+```c++
+template <class T>
+WindowStates MainStateLoop(T current_state, sf::RenderWindow& window)
+{
+	sf::Event event;
+	// When next_state is NONE then do not leave current state
+	WindowStates next_state = WindowStates::NONE;
+	while (next_state == WindowStates::NONE && window.isOpen())
+	{
+		deltatime = deltatime_clock.restart().asSeconds() * 450.f;
+		while (window.pollEvent(event))
+		{
+			if (event.type == sf::Event::Closed)
+				window.close();
+
+			current_state.handle_event(event);
+		}
+
+		current_state.update(next_state);
+
+		window.clear();
+		current_state.show();
+		window.display();
+	}
+	return next_state;
+};
+```
+
+The above code makes use of the `template <>` c++ feature which allows a function to take in an object of any type and just assume that it has the correct interface (functions). This means that states can do the same process even when represented as different classes such as the `GameState` and the `MenuState`.
+
+The function then initialises some variables and begins the gameloop. It runs as long as the window is open or `next_state` is changed. `next_state` pretty much always takes the value of NONE, as that means that no state transitions should occur.
+
+When `next_state` changes, we see that the gameloop will terminate and the new state will be returned by the function. Then it will move back to the state loop shown here:
+
+```c++
+// Here define all states that can be moved to in the program
+MenuState menu_state(window);
+GameState game_state(window);
+
+// Begin the program in the MENU state
+WindowStates current_state = WindowStates::MENU;
+while (window.isOpen())
+{
+	window.setView(window.getDefaultView());
+	// Depending on WindowState run gameloop with correct class instance
+	// Once gameloop ends, it will return the next state and then redo this switch
+	// statement with the new state.
+	switch (current_state)
+	{
+		case WindowStates::GAME:
+			current_state = MainStateLoop(game_state, window);
+			break;
+
+		default:
+			std::cout << "Error: Window State is not defined - Defaulting to menu" << std::endl;
+
+		case WindowStates::MENU:
+			current_state = MainStateLoop(menu_state, window);
+			break;
+	}
+}
+```
+
+Here you can see the stateloop, which stays open as long as the window is open. It starts by resetting the window view, and then looks and the current state, which at the start is set the MENU.
+
+Depending on the current state it will run the `MainStateLoop` function which holds the gameloop on a particular state object. Once the gameloop ends, it will return the new state and that will be set to current_state.

src/Enemy.cpp

@@ -1,39 +1,33 @@
 #include "Enemy.hpp"
+#include "Sprite.hpp"
 
-Enemy::Enemy(sf::Vector2f _pos, sf::Vector2f _size) :
-	Hitbox { _pos, _size }
-{
-	// Load Texture
-	texture.loadFromFile("assets/enemy.png");
-	sprite.setTexture(texture);
-	size = sf::Vector2f(texture.getSize());
+Enemy::Enemy(sf::Vector2f _pos, sf::Vector2f target_size) :
+	Hitbox { _pos, target_size },
+	Sprite { "assets/enemy.png", _pos, target_size }
+{}
 
-	// Initialise Position
-	pos = _pos;
+Enemy::Enemy() :
+	Hitbox { sf::Vector2f(), sf::Vector2f() },
+	Sprite { "assets/enemy.png", sf::Vector2f(), sf::Vector2f() }
+{}
 
-	sprite.setPosition(pos);
-}
-
-void Enemy::updatePosition(StaticSprite* platforms, sf::Vector2f player_pos)
+void Enemy::updatePosition(std::vector<StaticSprite*>& platforms, sf::Vector2f player_pos)
 {
 	float speed = 0.4f;
 	const float horiz_vel = player_pos.x > pos.x ? speed : -speed;
 	update(horiz_vel);
 
-	for (unsigned int i = 0; i < 3; i++)
+	for (StaticSprite* platform : platforms)
 	{
-		if (overlaps(platforms[i]))
-		{
-			correctHitboxOverlap(platforms[i]);
-		}
+		if (overlaps(*platform))
+			correctHitboxOverlap(*platform);
 	}
 
-	// Gets direction to player
-
 	sprite.setPosition(pos);
 }
 
-sf::Vector2f Enemy::getPosition()
+void Enemy::setPosition(sf::Vector2f _pos)
 {
-	return pos;
+	pos = _pos;
+	update_sprite(pos, size);
 }

src/Enemy.hpp

@@ -2,6 +2,7 @@
 #define Enemy_H
 
 #include "Hitbox.hpp"
+#include "Sprite.hpp"
 #include "StaticSprite.hpp"
 
 /**
@@ -10,18 +11,19 @@
  * @param pos The initial position
  * @param size The width and height of the enemy's hitbox
  */
-class Enemy : public Hitbox
+class Enemy : public Hitbox, public Sprite
 {
 private:
 	sf::Texture texture;
 
 public:
-	sf::Sprite sprite;
 	Enemy(sf::Vector2f pos, sf::Vector2f size);
+	Enemy();
 
 	// Updates the position of the sprite
-	void updatePosition(StaticSprite* platforms, sf::Vector2f player_pos);
-	sf::Vector2f getPosition();
+	void updatePosition(std::vector<StaticSprite*>& platforms, sf::Vector2f player_pos);
+	// Force sets the position of the sprites
+	void setPosition(sf::Vector2f _pos);
 };
 
 #endif

src/Game/Background.cpp

@@ -0,0 +1,22 @@
+#include "Game/Background.hpp"
+
+Background::Background(sf::RenderWindow& window) :
+	Sprite { "assets/background-image.png", sf::Vector2f(0, 0), sf::Vector2f(window.getSize()) }
+{}
+
+/**
+ * Calculates where to place the background based on the player view,
+ * and draws it behind all other sprites.
+ *
+ * @param window A reference to the main window object
+ * @param view A reference to the currently active player view
+ */
+void Background::draw(sf::RenderWindow& window, sf::View& view)
+{
+	const sf::Vector2f view_center = view.getCenter();
+	const sf::Vector2f view_size = view.getSize();
+
+	const sf::Vector2f left_top = sf::Vector2f(view_center.x - view_size.x / 2, view_center.y - view_size.y / 2);
+	update_sprite(left_top, view_size);
+	window.draw(sprite);
+}

src/Game/Background.hpp

@@ -0,0 +1,20 @@
+#ifndef Background_H
+#define Background_H
+
+#include "Sprite.hpp"
+
+/**
+ * A sprite that draws a static image to the background during the game.
+ * It takes into account the moving window view and adjusts the background position to
+ * account for it.
+ *
+ * @param window A reference to the window
+ */
+class Background : public Sprite
+{
+public:
+	Background(sf::RenderWindow& _window);
+	void draw(sf::RenderWindow& window, sf::View& view);
+};
+
+#endif

src/Game/Game.cpp

@@ -0,0 +1,103 @@
+#include "Game/Game.hpp"
+
+/**
+ * Initialise all objects and classes inside the game
+ */
+Game::Game(sf::RenderWindow& _window) :
+	window { _window },
+	player { sf::Vector2f(500.f, 0.f), sf::Vector2f(215.f, 258.f) },
+	platforms {
+		new StaticSprite("assets/platform.png", sf::Vector2f(10.f, 500.f), sf::Vector2f(760.f, 107.f)),
+		new StaticSprite("assets/platform.png", sf::Vector2f(1100.f, 100.f), sf::Vector2f(760.f, 107.f)),
+		new StaticSprite("assets/platform.png", sf::Vector2f(2100.f, 500.f), sf::Vector2f(760.f, 107.f))
+	},
+	enemies {
+		new Enemy(sf::Vector2f(0.f, -100.f), sf::Vector2f(215.f, 258.f)),
+		new Enemy(sf::Vector2f(2700.f, -100.f), sf::Vector2f(215.f, 258.f))
+	},
+	player_view { sf::FloatRect(0, 0, window.getSize().x, window.getSize().y) }
+{
+	reset_positions(true);
+}
+
+/**
+ * Resets the positions of the player (and possibly enemies)
+ *
+ * @param hard_reset Whether to reset enemies as well
+ */
+void Game::reset_positions(bool hard_reset)
+{
+	player.setDetails(sf::Vector2f(500.f, 0.f), player.size);
+	if (hard_reset)
+	{
+		enemies[0]->setPosition(sf::Vector2f(0.f, 250.f));
+		enemies[1]->setPosition(sf::Vector2f(2700.f, 250.f));
+	}
+}
+
+void Game::handleKeyPress(sf::Keyboard::Key key_code)
+{
+	player.handleKeyPress(key_code);
+}
+
+void Game::handleKeyRelease(sf::Keyboard::Key key_code)
+{
+	player.handleKeyRelease(key_code);
+}
+
+void Game::update(WindowStates& next_state)
+{
+	if (player.health < 0)
+	{
+		// If the player has died, go to Menu screen (TODO: implement GameOver screen)
+		next_state = WindowStates::MENU;
+		return;
+	}
+
+	player.updatePosition(platforms);
+
+	for (Enemy* enemy : enemies)
+	{
+		enemy->updatePosition(platforms, player.pos);
+		player.handleCollide(*enemy);
+	}
+
+	player.updateHealth();
+
+	// Update information in frame_tracker text widget
+	frame_tracker.add_info("Vel", std::to_string(player.vel.x).substr(0, 4) + "  |  " + std::to_string(player.vel.y).substr(0, 4));
+	frame_tracker.update();
+}
+
+void Game::moveViewToPlayer()
+{
+	player_view.setCenter(sf::Vector2f(player.pos.x, 300));
+	window.setView(player_view);
+}
+
+void Game::draw()
+{
+	for (Enemy* enemy : enemies)
+	{
+		enemy->draw(window);
+
+		if (show_hitboxes)
+			window.draw(enemy->get_hitbox_outline());
+	}
+
+	for (StaticSprite* platform : platforms)
+	{
+		platform->draw(window);
+
+		if (show_hitboxes)
+			window.draw(platform->get_hitbox_outline());
+	}
+
+	player.draw(window);
+
+	if (show_hitboxes)
+		window.draw(player.get_hitbox_outline());
+
+	window.draw(frame_tracker.text);
+	window.draw(player.health_display);
+}