Network

.gitmodules

@@ -19,3 +19,6 @@
 [submodule "deps/libpqxx"]
 	path = deps/libpqxx
 	url = https://github.com/jtv/libpqxx
+[submodule "deps/cpp-httplib"]
+	path = deps/cpp-httplib
+	url = https://github.com/yhirose/cpp-httplib

CMakeLists.txt

@@ -86,6 +86,13 @@ add_subdirectory(${DIRECTORY_PQXX})
 message(STATUS "PostgreSQL include: ${INCLUDE_PQXX}")
 message(STATUS "PostgreSQL library: ${LIBRARY_PQXX}")
 
+# HTTP library
+set(DIRECTORY_HTTP ${PROJECT_SOURCE_DIR}/deps/cpp-httplib)
+set(INCLUDE_HTTP ${DIRECTORY_HTTP})
+
+add_subdirectory(${DIRECTORY_HTTP})
+message(STATUS "HTTP include: ${INCLUDE_HTTP}")
+
 # Core library
 set(DIRECTORY_CORE ${PROJECT_SOURCE_DIR}/core)
 set(INCLUDE_CORE ${DIRECTORY_CORE})
@@ -100,11 +107,21 @@ set(DIRECTORY_GAME ${PROJECT_SOURCE_DIR}/game)
 set(EXECUTABLE_GAME example)
 set(EXECUTABLE_GAME_RUNNER game_runner_example)
 set(EXECUTABLE_GAME_DATABASE game_database_example)
+set(EXECUTABLE_LOADER_FROM_SERVER game_loader_from_server_example)
 
 add_subdirectory(${DIRECTORY_GAME})
 message(STATUS "Game executable: ${EXECUTABLE_GAME}")
 message(STATUS "Game-runner executable ${EXECUTABLE_GAME_RUNNER}")
 
+# Network binaries
+set(DIRECTORY_NETWORK ${PROJECT_SOURCE_DIR}/network)
+set(EXECUTABLE_SIMPLE_SERVER simple-server)
+set(EXECUTABLE_SIMPLE_CLIENT simple-client)
+
+add_subdirectory(${DIRECTORY_NETWORK})
+message(STATUS "Server executable: ${EXECUTABLE_SERVER}")
+message(STATUS "Client executable ${EXECUTABLE_GAME_CLIENT}")
+
 # Tests
 set(DIRECTORY_TEST ${PROJECT_SOURCE_DIR}/test)
 set(EXECUTABLE_TEST test)

core/CMakeLists.txt

@@ -78,17 +78,22 @@ set(
         runner/GameRunner.hpp runner/GameRunner.cpp
         loader/LevelLoader.hpp
         loader/LevelLoaderFromFile.cpp loader/LevelLoaderFromFile.hpp
+        loader/LevelLoaderFromServer.hpp loader/LevelLoaderFromServer.cpp
 
         visual/image/Image.hpp
         visual/image/static/RenderableStatic.cpp visual/image/static/RenderableStatic.hpp
         visual/image/shape/square/RenderableSquare.cpp visual/image/shape/square/RenderableSquare.hpp
         visual/image/animated/RenderableAnimatedOneFile.cpp visual/image/animated/RenderableAnimatedOneFile.hpp
         visual/image/animated/RenderableAnimatedSeveralFiles.cpp visual/image/animated/RenderableAnimatedSeveralFiles.hpp
+        visual/image/background/RenderableBackground.cpp visual/image/background/RenderableBackground.hpp
+
         visual/image/shape/Shape.cpp visual/image/shape/Shape.hpp
         visual/image/shape/square/Square.cpp visual/image/shape/square/Square.hpp
         visual/image/static/StaticImage.cpp visual/image/static/StaticImage.hpp
         visual/image/animated/AnimatedImageOneFile.cpp visual/image/animated/AnimatedImageOneFile.hpp
         visual/image/animated/AnimatedImageSeveralFiles.cpp visual/image/animated/AnimatedImageSeveralFiles.hpp
+        visual/image/background/BackgroundImage.cpp visual/image/background/BackgroundImage.hpp
+
         visual/image/storage/ImageStorage.cpp visual/image/storage/ImageStorage.hpp
         visual/Renderable.hpp
         visual/Camera.cpp visual/Camera.hpp

core/database/database/Database.cpp

@@ -25,6 +25,11 @@ namespace mad::core {
                       "levels_completed SMALLINT NOT NULL);";
             w.exec(m_query);
 
+            m_query = "CREATE TABLE IF NOT EXISTS levels("
+                      "id SERIAL PRIMARY KEY,"
+                      "name TEXT NOT NULL UNIQUE);";
+            w.exec(m_query);
+
             w.commit();
 
             SPDLOG_DEBUG("Tables created successfully");
@@ -40,10 +45,17 @@ namespace mad::core {
         return !rows_found.empty();
     }
 
+    bool Database::is_level_exists(const std::string &levelname) {
+        pqxx::work W(m_connector);
+        m_query = "SELECT * FROM levels WHERE name = '" + W.esc(levelname) + "';";
+        pqxx::result rows_found = W.exec(m_query);
+        return !rows_found.empty();
+    }
+
     void Database::registry_user(const std::string &username) {
         pqxx::work W(m_connector);
 
-        m_query = "SELECT id FROM users";
+        m_query = "SELECT id FROM users;";
         pqxx::result total_rows = W.exec(m_query);
         std::size_t id = total_rows.size();
 
@@ -56,6 +68,15 @@ namespace mad::core {
         W.commit();
     }
 
+    void Database::append_level(const std::string &levelname) {
+        pqxx::work W(m_connector);
+
+        m_query = "INSERT INTO levels(name) VALUES('" + levelname + "');";
+        W.exec(m_query);
+
+        W.commit();
+    }
+
     std::size_t Database::get_id(const std::string &username) {
         pqxx::work W(m_connector);
         m_query = "SELECT * FROM users WHERE name = '" + W.esc(username) + "';";
@@ -99,4 +120,18 @@ namespace mad::core {
     void Database::reset_progress(const std::string &username) {
         reset_progress(get_id(username));
     }
+
+    std::string Database::get_levelname(std::size_t id) {
+        pqxx::work W(m_connector);
+        m_query = "SELECT * FROM levels WHERE id = " + std::to_string(id) + ";";
+        auto found_row = W.exec1(m_query);
+        return found_row["name"].as<std::string>();
+    }
+
+    std::size_t Database::get_levels_total() {
+        pqxx::work W(m_connector);
+        m_query = "SELECT id FROM levels;";
+        auto total_rows = W.exec(m_query);
+        return total_rows.size();
+    }
 }

core/database/database/Database.hpp

@@ -3,6 +3,7 @@
 
 #include <pqxx/pqxx>
 #include <cstddef>
+#include <mutex>
 
 
 namespace mad::core {
@@ -13,13 +14,21 @@ namespace mad::core {
 
         bool is_user_exists(const std::string &username);
 
-        void registry_user(const std::string &username);
+        bool is_level_exists(const std::string &levelname);
 
         std::size_t get_id(const std::string &username);
 
         std::size_t get_progress(std::size_t id);
         std::size_t get_progress(const std::string &username);
 
+        std::string get_levelname(std::size_t id);
+
+        std::size_t get_levels_total();
+
+        void registry_user(const std::string &username);
+
+        void append_level(const std::string &levelname);
+
         void increment_progress(std::size_t id);
         void increment_progress(const std::string &username);
 

core/loader/LevelLoaderFromFile.cpp

@@ -1,10 +1,7 @@
 #include "LevelLoaderFromFile.hpp"
 #include <event/management/condition/CollisionCondition.hpp>
-#include "event/management/condition/KeyDownCondition.hpp"
-#include "event/management/condition/KeyPressedCondition.hpp"
-#include "event/management/condition/TimerCondition.hpp"
-#include "event/management/condition/TrueCondition.hpp"
-#include "event/management/controller/statemachine/StateMachine.hpp"
+#include <event/management/condition/TimerCondition.hpp>
+#include <event/management/controller/statemachine/StateMachine.hpp>
 
 #include <common/Error.hpp>
 
@@ -25,7 +22,7 @@ namespace mad::core {
 
         Vec2d camera_position = {m_config_json["camera"]["position"]["x"],
                                  m_config_json["camera"]["position"]["y"]};
-        auto camera = std::make_shared<mad::core::Camera>(camera_position, world, true);
+        auto camera = std::make_shared<mad::core::Camera>(camera_position, world);
 
         auto keys = create_world(world);
 
@@ -82,6 +79,9 @@ namespace mad::core {
         float current_position_y = object_size / 2;
         std::unordered_map<LevelLoaderFromFile::IdKeys, Entity::Id> keys;
         std::string map_line;
+
+        create_background(world);
+
         while (std::getline(m_level_map, map_line)) {
             for (char object: map_line) {
                 switch (m_objects[object]) {
@@ -133,7 +133,7 @@ namespace mad::core {
     void LevelLoaderFromFile::create_block(std::shared_ptr<LocalWorld> world,
                                            Vec2d position, float block_size, bool is_stable) {
 
-        std::filesystem::path source("../../game/resources/static/");
+        std::filesystem::path source("../../resources/static/");
         if (is_stable) {
             source /= static_cast<std::string>(m_config_json["texture"]["stable"]);
         } else {
@@ -203,7 +203,7 @@ namespace mad::core {
     }
 
     Entity::Id LevelLoaderFromFile::create_finish_block(std::shared_ptr<LocalWorld> world, Vec2d position, float block_size) {
-        std::filesystem::path source("../../game/resources/static/");
+        std::filesystem::path source("../../resources/static/");
         source /= static_cast<std::string>(m_config_json["texture"]["finish"]);
 
         auto image_storage = std::make_shared<ImageStorage>(
@@ -223,4 +223,29 @@ namespace mad::core {
         );
     }
 
+    void LevelLoaderFromFile::create_background(std::shared_ptr<LocalWorld> world) {
+        std::filesystem::path source(m_config_json["background"]["source"]);
+
+        std::shared_ptr<ImageStorage> image_storage;
+        std::vector<float> parallax_ratios = m_config_json["background"]["parallax_ratios"];
+
+        image_storage = std::make_shared<ImageStorage>(
+                std::unordered_map<ImageStorage::TypeAction, std::shared_ptr<Image>>(
+                        {{ImageStorage::TypeAction::Idle,
+                          std::make_shared<BackgroundImage>(
+                                  source,
+                                  parallax_ratios,
+                                  m_config_json["background"]["scale"]
+                                  )
+                        }}
+                )
+        );
+        world->create_viewable_entity(
+                -1,
+                {0, 0},
+                0,
+                image_storage
+        );
+    }
+
 }

core/loader/LevelLoaderFromFile.hpp

@@ -106,6 +106,8 @@ namespace mad::core {
 
         Entity::Id create_hero(std::shared_ptr<LocalWorld> world, Vec2d position);
 
+        void create_background(std::shared_ptr<LocalWorld> world);
+
         Entity::Id create_finish_block(std::shared_ptr<LocalWorld> world, Vec2d position, float block_size);
 
     private:
@@ -116,7 +118,7 @@ namespace mad::core {
             Hero,
             Enemy1,
             Enemy2,
-            Empty,
+            Empty
         };
 
         std::filesystem::path m_level_directory;