Adds basic logging setup using a static logger and a few logging levels

src/engine/engine.cpp

@@ -23,6 +23,7 @@ void Engine::start_loop() {
     renderer->flush();
     auto game_params = GameInitArgs{this->config.target_fps, this->config.window_width, this->config.window_height};
     game->initialize(game_params);
+    Logger::log(LogLevel::DEBUG, "Engine init finished");
     std::vector<std::unique_ptr<RenderingPipelineStep>> rendering_steps = build_render_pipline();
     auto duration_per_frame = one_second_milli / this->config.target_fps;
     while(true) {
@@ -53,6 +54,7 @@ Engine::Engine(std::unique_ptr<Game> game,
     this->game = std::move(game);
     this->input_processor = std::move(input_processor);
     this->parse_config(ENGINE_CONFIG_FILE);
+    Logger::set_minimum_loglevel(LogLevel::DEBUG);
     this->setup_renderer(this->config.selected_renderer);
 }
 

src/engine/engine.hpp

@@ -14,6 +14,7 @@
 #include "rendering/renderer.hpp"
 #include "input/inputprocessor.hpp"
 #include "rendering/renderingpipelinestep.hpp"
+#include "modules/logger.hpp"
 
 #define MISSING_GAME_ERROR "Game pointer is null"
 #define MISSING_RENDERER_ERROR "Renderer pointer is null"

src/engine/modules/logger.cpp

@@ -0,0 +1,47 @@
+//
+// Created by m on 7/18/23.
+//
+#include "logger.hpp"
+#include <fmt/format.h>
+#include <fmt/chrono.h>
+#include <iostream>
+
+LogLevel Logger::minimum_loglevel = LogLevel::DEBUG;
+
+void Logger::set_minimum_loglevel(LogLevel logLevel) {
+    Logger::minimum_loglevel = logLevel;
+}
+
+void Logger::log(LogLevel level, const std::string &msg) {
+    if(level < Logger::minimum_loglevel) {
+        return;
+    }
+
+    auto loglevel_name = "UNKNOWN";
+    switch (level) {
+        case LogLevel::TRACE:
+            loglevel_name = "TRA";
+            break;
+        case DEBUG:
+            loglevel_name = "DEB";
+            break;
+        case INFO:
+            loglevel_name = "INF";
+            break;
+        case WARNING:
+            loglevel_name = "WAR";
+            break;
+        case ERROR:
+            loglevel_name = "ERR";
+            break;
+        case NONE:
+            loglevel_name = "NON";
+            break;
+    }
+    auto output = fmt::format("[{}][{}] {}", std::chrono::system_clock::now(), loglevel_name, msg);
+
+    if(level == LogLevel::ERROR) {
+        std::cerr << output << "\n";
+    }
+    std::cout << output << "\n";
+}

src/engine/modules/logger.hpp

@@ -0,0 +1,29 @@
+//
+// Created by m on 7/18/23.
+//
+
+#ifndef RLA_IIPP_LOGGER_HPP
+#define RLA_IIPP_LOGGER_HPP
+
+#include <string>
+#include <unordered_map>
+
+enum LogLevel: int {
+    TRACE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARNING = 3,
+    ERROR = 4,
+    NONE = 5
+};
+
+class Logger {
+public:
+    static void set_minimum_loglevel(LogLevel logLevel);
+    static void log(LogLevel level, const std::string& msg);
+private:
+    static LogLevel minimum_loglevel;
+};
+
+
+#endif //RLA_IIPP_LOGGER_HPP

src/engine/rendering/pipeline_steps/fpscounterrenderingstep.cpp

@@ -6,7 +6,8 @@
 #include "fpscounterrenderingstep.hpp"
 
 void FpsCounterRenderingStep::render_step(Renderer *renderer) {
-    double frames = 1;
+    const double frames = 1;
+    const double smooth = 0.9;
     std::chrono::time_point<std::chrono::system_clock> end = std::chrono::system_clock::now();
     std::chrono::duration<double> dur = end - this->lastFrame;
     renderer->draw_text(std::nullopt, fmt::format("{:.2f}", frames/dur.count()), 0, 0);

src/game/visualizer.cpp

@@ -63,6 +63,7 @@ void Visualizer::initialize(GameInitArgs args) {
     this->camera = Camera(Point{x,y}, tilesx, tilesy, tile_map.get_width(), tile_map.get_height());
     this->algorithm_manager = AlgorithmManager(args.target_fps);
     this->initialize_context();
+    Logger::log(LogLevel::DEBUG, "Game initialization finished");
 }
 
 void Visualizer::initialize_map(int width, int height) {