Main menu

.gitignore

@@ -1,4 +1,5 @@
 **/.DS_Store
+.editorconfig
 .vscode
 .cache
 build

CMakeLists.txt

@@ -51,7 +51,13 @@ add_library(
   src/Trace.cpp
   src/Players/DummyPlayer.cpp
   src/Players/KeyboardPlayer.cpp
-  src/Sound.cpp)
+  src/Sound.cpp
+  src/MainMenu.cpp
+  src/GameManager.cpp
+  src/MenuLevel.cpp
+  src/Button.cpp
+  src/MenuItem.cpp
+  )
 
 target_include_directories(tank_bot_fight_lib PRIVATE src)
 

src/Board.cpp

@@ -11,10 +11,8 @@
 #include "Tank/TankFactory.hpp"
 #include "TracesHandler.hpp"
 
-Board::Board()
-    : mWindow(sf::VideoMode(WIDTH, HEIGHT), "TankBotFight"),
-      mBackground(mStore),
-      mTankExplodeSound("explosion.flac") {
+Board::Board(sf::RenderWindow& window)
+    : mWindow{window}, mBackground(mStore), mTankExplodeSound{"explosion.flac"} {
   constexpr float TANK_X = WIDTH / 2.0f;
   constexpr float TANK_Y = 50.f;
   constexpr float TANK2_X = WIDTH / 2.0f;
@@ -31,7 +29,6 @@ Board::Board()
 void Board::register_missile(const Missle& missile) { mMissles.push_back(missile); }
 
 void Board::draw() {
-  mWindow.clear();
   mBackground.draw(mWindow);
   if (mKeyboardPlayer) {
     mKeyboardPlayer->draw(mWindow);
@@ -46,34 +43,23 @@ void Board::draw() {
     animation.draw(mWindow);
   };
   display_speed();
-  mWindow.display();
 }
 
-void Board::run() {
-  while (mWindow.isOpen()) {
-    sf::Event event{};
-    while (mWindow.pollEvent(event)) {
-      if (event.type == sf::Event::Closed) {
-        mWindow.close();
-      }
+void Board::play(const sf::Event& event) {
+  if (mKeyboardPlayer) {
+    mKeyboardPlayer->handle_events(event);
+  }
 
-      if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
-        mWindow.close();
-      }
-      if (mKeyboardPlayer) {
-        mKeyboardPlayer->handle_events(event);
-      }
-    }
-    if (mDummyPlayer) {
-      mDummyPlayer->update();
-    }
-    if (mKeyboardPlayer) {
-      mKeyboardPlayer->update();
-    }
-    draw();
-    remove_missles();
-    update_players();
+  if (mDummyPlayer) {
+    mDummyPlayer->update();
+  }
+
+  if (mKeyboardPlayer) {
+    mKeyboardPlayer->update();
   }
+  draw();
+  remove_missles();
+  update_players();
 }
 
 void Board::display_speed() {

src/Board.hpp

@@ -10,11 +10,11 @@
 #include "background/Background.hpp"
 class Board {
  public:
-  Board();
+  Board(sf::RenderWindow& window);
 
   void register_missile(const Missle& missile);
   void register_animation(const Animation& animation);
-  void run();
+  void play(const sf::Event& event);
 
  private:
   void remove_missles();
@@ -23,7 +23,7 @@ class Board {
   void draw();
 
   TextureStore mStore;
-  sf::RenderWindow mWindow;
+  sf::RenderWindow& mWindow;
   Background mBackground;
   std::unique_ptr<KeyboardPlayer> mKeyboardPlayer;
   std::unique_ptr<DummyPlayer> mDummyPlayer;

src/Button.cpp

@@ -0,0 +1,54 @@
+#include "Button.hpp"
+
+Button::Button(std::string text, sf::Vector2f top_left_corner, unsigned int width,
+               unsigned int height, void (*callback)(void), ButtonType button_type,
+               MenuLevel* next_level)
+    : mTextContent{text},
+      mCallback{callback},
+      MenuItem{top_left_corner},
+      mWidth{width},
+      mHeight{height},
+      mButtonType{button_type},
+      mNextLevel{next_level} {}
+
+void Button::draw(sf::RenderWindow& window, const sf::Font& font) {
+  // draw rectangle
+  sf::RectangleShape rectangle(sf::Vector2f(mWidth, mHeight));
+
+  // draw rectangle outline
+  if (mIsSelected) {
+    rectangle.setOutlineThickness(10.0f);
+    rectangle.setOutlineColor(sf::Color(255, 0, 0));
+  } else {
+    rectangle.setOutlineThickness(0.0f);
+  }
+
+  // set text
+  mText.setFont(font);
+  mText.setCharacterSize(24);
+  mText.setColor(sf::Color::Red);
+  mText.setString(mTextContent);
+
+  // move objects in window and draw
+  rectangle.setPosition(mPosition);
+  window.draw(rectangle);
+
+  // center text
+  mText.setOrigin(mText.getGlobalBounds().getSize() / 2.f + mText.getLocalBounds().getPosition());
+  mText.setPosition(rectangle.getPosition() + (rectangle.getSize() / 2.f));
+  window.draw(mText);
+}
+
+void Button::select() { mIsSelected = true; }
+
+void Button::deselect() { mIsSelected = false; }
+
+void Button::click() {
+  if (mButtonType == ButtonType::Callback && mIsSelected) {
+    mCallback();
+  }
+}
+
+ButtonType Button::get_button_type() const { return mButtonType; }
+
+MenuLevel* Button::get_next_level() const { return mNextLevel; }

src/Button.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <SFML/Graphics.hpp>
+#include <string>
+#include <vector>
+
+#include "MenuItem.hpp"
+#include "MenuLevel.hpp"
+
+enum class ButtonType { Callback, LevelChanger };
+
+class MenuLevel;
+
+class Button : MenuItem {
+ public:
+  Button(std::string text, sf::Vector2f top_left_corner, unsigned int width, unsigned int height,
+         void (*callback)(void), ButtonType button_type, MenuLevel* next_level = nullptr);
+  void draw(sf::RenderWindow& window, const sf::Font& font);
+  void select();
+  void deselect();
+  void click();
+  ButtonType get_button_type() const;
+  MenuLevel* get_next_level() const;
+
+ private:
+  std::string mTextContent;
+  sf::Text mText;
+  unsigned int mWidth;
+  unsigned int mHeight;
+  void (*mCallback)(void);
+  bool mIsSelected = false;
+  MenuLevel* mNextLevel;
+  ButtonType mButtonType;
+};

src/GameManager.cpp

@@ -0,0 +1,97 @@
+#include "GameManager.hpp"
+
+#include "Size.hpp"
+
+// define static variables
+bool GameManager::request_state_change = false;
+GameManagerState GameManager::desired_state = GameManagerState::InvalidState;
+
+// Button callbacks:
+void main_menu_start_callback(void) {
+  GameManager::request_state_change = true;
+  GameManager::desired_state = GameManagerState::Started;
+}
+void main_menu_exit_callback(void) {
+  GameManager::request_state_change = true;
+  GameManager::desired_state = GameManagerState::Exit;
+}
+
+// define menus
+extern MenuLevel options;
+
+const unsigned int buttonWidth = WIDTH / 5;
+const unsigned int buttonHeight = HEIGHT / 10;
+constexpr unsigned int verticalSpacing = 20;
+
+MenuLevel main_menu{
+    {{"Start", sf::Vector2f((WIDTH - buttonWidth) / 2, verticalSpacing + buttonHeight * 1),
+      buttonWidth, buttonHeight, main_menu_start_callback, ButtonType::Callback, nullptr},
+     {"Options", sf::Vector2f((WIDTH - buttonWidth) / 2, verticalSpacing + buttonHeight * 3),
+      buttonWidth, buttonHeight, nullptr, ButtonType::LevelChanger, &options},
+     {"Exit", sf::Vector2f((WIDTH - buttonWidth) / 2, verticalSpacing + buttonHeight * 5),
+      buttonWidth, buttonHeight, main_menu_exit_callback, ButtonType::Callback, nullptr}}};
+
+MenuLevel options{{"Back", sf::Vector2f(WIDTH / 2 - buttonWidth, 2 * buttonHeight + 20),
+                   buttonWidth, buttonHeight, nullptr, ButtonType::LevelChanger, &main_menu}};
+
+GameManager::GameManager()
+    : mWindow{sf::VideoMode(WIDTH, HEIGHT), "TankBotFight"},
+      mBoard{mWindow},
+      mMainMenu{mWindow, {&main_menu, &options}, &main_menu} {}
+
+void GameManager::start() {
+  while (mWindow.isOpen()) {
+    sf::Event event;
+    while (mWindow.pollEvent(event)) {
+      if (event.type == sf::Event::Closed) {
+        mGameManagerState = GameManagerState::Exit;
+      }
+      if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
+        mGameManagerState = GameManagerState::Exit;
+      }
+    }
+
+    // clear the window with black color
+    mWindow.clear(sf::Color::Black);
+
+    performStateMachine(event);
+
+    // end the current frame
+    mWindow.display();
+  }
+}
+
+void GameManager::performStateMachine(const sf::Event& event) {
+  switch (mGameManagerState) {
+    case GameManagerState::MainMenu:
+      mMainMenu.process_and_draw(event);
+      break;
+    case GameManagerState::Started:
+      mBoard.play(event);
+      break;
+    case GameManagerState::Exit:
+      mWindow.close();
+      break;
+  }
+
+  // check if state change is requested
+  if (request_state_change) {
+    request_state_change = false;
+    transitState();
+  }
+}
+
+void GameManager::transitState() {
+  switch (mGameManagerState) {
+    case GameManagerState::MainMenu:
+      if (desired_state == GameManagerState::Started) {
+        mGameManagerState = GameManagerState::Started;
+      } else if (desired_state == GameManagerState::Exit) {
+        mGameManagerState = GameManagerState::Exit;
+      }
+      break;
+    case GameManagerState::Started:
+      // TODO -> pause game
+      break;
+  }
+}

src/GameManager.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <SFML/Graphics.hpp>
+
+#include "Board.hpp"
+#include "MainMenu.hpp"
+
+enum class GameManagerState {
+  MainMenu,
+  Started,
+  Exit,
+  InvalidState,
+};
+
+class GameManager {
+ public:
+  GameManager();
+  void start();
+  void performStateMachine(const sf::Event& event);
+  void transitState();
+
+ private:
+  // objects
+  GameManagerState mGameManagerState = GameManagerState::MainMenu;
+  sf::RenderWindow mWindow;
+  MainMenu mMainMenu;
+  Board mBoard;
+  static bool request_state_change;
+  static GameManagerState desired_state;
+
+  // friends: buttons' callbacks
+  friend void main_menu_start_callback(void);
+  friend void main_menu_exit_callback(void);
+};

src/MainMenu.cpp

@@ -0,0 +1,23 @@
+#include "MainMenu.hpp"
+
+#include "Files.hpp"
+
+MainMenu::MainMenu(sf::RenderWindow& window, std::initializer_list<MenuLevel*> menu_level_ptrs,
+                   MenuLevel* current_level)
+    : mWindow{window}, mMenuLevelPtrs{menu_level_ptrs}, mCurrentLevel{current_level} {
+  mFont.loadFromFile(files::asset_path() + "DejaVuSans.ttf");
+}
+
+void MainMenu::process_and_draw(const sf::Event& event) {
+  // check if menu should be changed
+  if (mCurrentLevel->is_level_change_requested()) {
+    mCurrentLevel->reset_level_request();
+    mCurrentLevel = mCurrentLevel->get_next_level();
+  }
+
+  // process inputs
+  mCurrentLevel->processEvents(event);
+
+  // draw menu
+  mCurrentLevel->draw(mWindow, mFont);
+}

src/MainMenu.hpp

@@ -0,0 +1,19 @@
+#pragma once
+#include <SFML/Graphics.hpp>
+#include <iostream>
+
+#include "Button.hpp"
+#include "MenuLevel.hpp"
+
+class MainMenu {
+ public:
+  MainMenu(sf::RenderWindow& window, std::initializer_list<MenuLevel*> menu_level_ptrs,
+           MenuLevel* current_level);
+  void process_and_draw(const sf::Event& event);
+
+ private:
+  sf::RenderWindow& mWindow;
+  std::vector<MenuLevel*> mMenuLevelPtrs;
+  MenuLevel* mCurrentLevel = nullptr;
+  sf::Font mFont;
+};

src/MenuItem.cpp

@@ -0,0 +1,3 @@
+#include "MenuItem.hpp"
+
+MenuItem::MenuItem(sf::Vector2f position) : mPosition{position} {}