Release branch

.github/workflows/build_and_run_tests.yml

@@ -4,9 +4,9 @@ name: CI
 
 on:
   push:
-    branches: [ main ]
+    branches: [ main, release_branch ]
   pull_request:
-    branches: [ main ]
+    branches: [ main, release_branch ]
 
 jobs:
 

.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,6 +78,7 @@ 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
@@ -103,7 +104,7 @@ set(
         event/management/condition/KeyDownCondition.hpp event/management/condition/KeyDownCondition.cpp
         event/management/condition/TimerCondition.hpp event/management/condition/TimerCondition.cpp
         event/management/condition/CollisionCondition.hpp event/management/condition/CollisionCondition.cpp
-        event/WorldUpdate.hpp event/WorldUpdate.cpp)
+        event/WorldUpdate.hpp event/WorldUpdate.cpp ../game/mobs/hero/Hero.hpp ../game/mobs/hero/Hero.cpp event/management/condition/KeyReleasedCondition.hpp event/management/condition/KeyReleasedCondition.cpp event/management/controller/JumpImpulse.hpp event/management/controller/JumpImpulse.cpp event/management/condition/LastStateCondition.hpp event/management/condition/LastStateCondition.cpp event/management/controller/Movement.hpp event/management/controller/Movement.cpp event/management/controller/StartJump.hpp event/management/controller/StartJump.cpp event/management/controller/FlyUp.hpp event/management/controller/FlyUp.cpp event/management/controller/Fall.hpp event/management/controller/Fall.cpp event/management/controller/GroundMovement.hpp event/management/controller/GroundMovement.cpp event/management/condition/EndAnimationCondition.hpp event/management/condition/EndAnimationCondition.cpp event/management/condition/FallCondition.hpp event/management/condition/FallCondition.cpp event/physics/SensorCollision.hpp event/physics/SensorCollision.cpp event/management/condition/SensorCondition.hpp event/management/condition/SensorCondition.cpp event/management/controller/Attack.cpp event/management/controller/Attack.hpp event/physics/SensorCollisionEnd.hpp event/physics/SensorCollisionEnd.cpp event/management/condition/SensorEndCondition.hpp event/management/condition/SensorEndCondition.cpp event/management/controller/statemachine/HeroStateMachine.hpp event/management/controller/statemachine/HeroStateMachine.cpp event/management/controller/statemachine/EnemyStateMachine.hpp event/management/controller/statemachine/EnemyStateMachine.cpp event/management/controller/EnemyAttack.hpp event/management/controller/EnemyAttack.cpp event/management/controller/Die.hpp event/management/controller/Die.cpp event/management/controller/Destroy.hpp event/management/controller/Destroy.cpp world/filter/RadiusFilter.hpp event/management/controller/DealDamage.hpp event/management/controller/DealDamage.cpp event/physics/TakeDamage.hpp event/physics/TakeDamage.cpp event/management/condition/TakeDamageCondition.hpp event/management/condition/TakeDamageCondition.cpp event/management/controller/Hurt.hpp event/management/controller/Hurt.cpp event/management/condition/Counter.hpp event/management/condition/Counter.cpp event/management/condition/EnemyAttackCondition.hpp event/management/condition/EnemyAttackCondition.cpp event/physics/Death.hpp event/physics/Death.cpp event/management/condition/FallDownCondition.hpp event/management/condition/FallDownCondition.cpp)
 
 add_library(
         ${LIBRARY_CORE} STATIC

core/common/FVec2D.cpp

@@ -51,4 +51,6 @@ namespace mad::core {
     Vec2d operator*(float k, Vec2d v) {
         return v *= k;
     }
+
+
 }

core/common/FVec2D.hpp

@@ -14,7 +14,6 @@ namespace mad::core {
 
         operator sf::Vector2<float>() const;
 
-
         [[nodiscard]] float get_x() const noexcept;
 
         [[nodiscard]] float get_y() const noexcept;

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");
@@ -33,17 +38,28 @@ namespace mad::core {
         }
     }
 
+    Database::~Database() {
+        drop_levels();
+    }
+
     bool Database::is_user_exists(const std::string &username) {
         pqxx::work W(m_connector);
         m_query = "SELECT * FROM users WHERE name = '" + W.esc(username) + "';";
         pqxx::result rows_found = W.exec(m_query);
         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 +72,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 +124,25 @@ 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();
+    }
+
+    void Database::drop_levels() {
+        pqxx::work W(m_connector);
+        m_query = "DROP TABLE levels;";
+        W.exec(m_query);
+        W.commit();
+    }
 }

core/database/database/Database.hpp

@@ -3,6 +3,7 @@
 
 #include <pqxx/pqxx>
 #include <cstddef>
+#include <mutex>
 
 
 namespace mad::core {
@@ -13,19 +14,31 @@ 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);
 
         void reset_progress(std::size_t id);
         void reset_progress(const std::string &username);
 
+        void drop_levels();
+
+        ~Database();
+
     private:
         pqxx::connection m_connector;
         std::string m_query;

core/event/Event.hpp

@@ -17,7 +17,11 @@ namespace mad::core {
             LevelPause,
             Runner,
             WorldUpdate,
-            EndOfRenderAction
+            EndOfRenderAction,
+            SensorCollision,
+            SensorCollisionEnd,
+            TakeDamage,
+            Death,
         };
 
         explicit Event(Type new_type);

core/event/management/condition/Condition.hpp

@@ -18,6 +18,8 @@ namespace mad::core {
         virtual void on_start() = 0;
 
         virtual ~Condition() = default;
+
+        bool triggered;
     };
 
 }

core/event/management/condition/Counter.cpp

@@ -0,0 +1,11 @@
+#include "Counter.hpp"
+mad::core::Counter::Counter(int *c, int mx) : c(c), mx(mx){
+}
+bool mad::core::Counter::is_triggered_by(const mad::core::Event &event) {
+    return *c >= mx;
+}
+std::unordered_set<mad::core::Event::Type> mad::core::Counter::triggers() {
+    return {Event::Type::WorldUpdate};
+}
+void mad::core::Counter::on_start() {
+}

core/event/management/condition/Counter.hpp

@@ -0,0 +1,20 @@
+#ifndef MAD_COUNTER_HPP
+#define MAD_COUNTER_HPP
+
+#include "Condition.hpp"
+namespace mad::core {
+    struct Counter : Condition {
+    public:
+        Counter(int *c, int mx);
+        bool is_triggered_by(const mad::core::Event &event) override;
+        std::unordered_set<Event::Type> triggers() override;
+        void on_start() override;
+
+    private:
+        int *c;
+        int mx;
+    };
+}// namespace mad::core
+
+
+#endif//MAD_COUNTER_HPP

core/event/management/condition/EndAnimationCondition.cpp

@@ -0,0 +1,21 @@
+#include "EndAnimationCondition.hpp"
+#include "common/Cast.hpp"
+#include "spdlog/spdlog.h"
+#include <event/action/EndOfRenderAction.hpp>
+mad::core::EndAnimationCondition::EndAnimationCondition(Entity::Id m_entity_id, ImageStorage::TypeAction m_type_action, int *stage) : m_entity_id(m_entity_id), m_type_action(m_type_action), stage(stage){
+}
+bool mad::core::EndAnimationCondition::is_triggered_by(const mad::core::Event &event) {
+    auto e = const_cast_to<EndOfRenderAction>(event);
+    if(m_entity_id == e.get_entity_id() && m_type_action == e.get_type_action()){
+        (*stage)++;
+        //SPDLOG_DEBUG("current attack_stage {}", *stage);
+    }
+    //SPDLOG_DEBUG("current attack_stage {}", *stage);
+    return m_entity_id == e.get_entity_id() && m_type_action == e.get_type_action();
+}
+std::unordered_set<mad::core::Event::Type> mad::core::EndAnimationCondition::triggers() {
+    return {mad::core::Event::Type::EndOfRenderAction};
+}
+void mad::core::EndAnimationCondition::on_start() {
+
+}

core/event/management/condition/EndAnimationCondition.hpp

@@ -0,0 +1,22 @@
+#ifndef MAD_ENDANIMATIONCONDITION_HPP
+#define MAD_ENDANIMATIONCONDITION_HPP
+
+#include "Condition.hpp"
+#include "visual/image/storage/ImageStorage.hpp"
+#include "world/entity/Entity.hpp"
+namespace mad::core {
+    struct EndAnimationCondition : Condition {
+    public:
+        explicit EndAnimationCondition(Entity::Id m_entity_id, ImageStorage::TypeAction m_type_action, int *stage = new int(0));
+        bool is_triggered_by(const mad::core::Event &event) override;
+        std::unordered_set<Event::Type> triggers() override;
+        void on_start() override;
+
+    private:
+        Entity::Id m_entity_id;
+        ImageStorage::TypeAction m_type_action;
+        int* stage;
+    };
+}// namespace mad::core
+
+#endif//MAD_ENDANIMATIONCONDITION_HPP

core/event/management/condition/EnemyAttackCondition.cpp

@@ -0,0 +1,20 @@
+#include "EnemyAttackCondition.hpp"
+#include "world/filter/RadiusFilter.hpp"
+mad::core::EnemyAttackCondition::EnemyAttackCondition(std::shared_ptr<mad::core::LocalWorld> world, Entity::Id hero_id, Entity::Id enemy_id) : world(world), hero_id(hero_id), enemy_id(enemy_id) {
+    hero_entity = cast_to_or_null<PhysicalEntity>(world->get_storage().get_entity(hero_id));
+    enemy_entity = cast_to_or_null<PhysicalEntity>(world->get_storage().get_entity(enemy_id));
+
+}
+std::unordered_set<mad::core::Event::Type> mad::core::EnemyAttackCondition::triggers() {
+    return {Event::Type::WorldUpdate};
+}
+bool mad::core::EnemyAttackCondition::is_triggered_by(const mad::core::Event &event) {
+    for(auto id : world->get_storage().extract(RadiusFilter(hero_entity->get_position(), 6.0f))){
+        if(id == enemy_id){
+            return true;
+        }
+    }
+    return false;
+}
+void mad::core::EnemyAttackCondition::on_start() {
+}

core/event/management/condition/EnemyAttackCondition.hpp

@@ -0,0 +1,27 @@
+#ifndef MAD_ENEMYATTACKCONDITION_HPP
+#define MAD_ENEMYATTACKCONDITION_HPP
+
+#include "Condition.hpp"
+#include "world/LocalWorld.hpp"
+#include "world/entity/Entity.hpp"
+#include <world/entity/PhysicalEntity.hpp>
+namespace mad::core {
+    struct EnemyAttackCondition : Condition {
+    public:
+        EnemyAttackCondition(std::shared_ptr<mad::core::LocalWorld> world, Entity::Id hero_id, Entity::Id enemy_id);
+        bool is_triggered_by(const mad::core::Event &event) override;
+        std::unordered_set<Event::Type> triggers() override;
+        void on_start() override;
+
+    private:
+        Entity::Id hero_id;
+        Entity::Id enemy_id;
+        PhysicalEntity* hero_entity;
+        PhysicalEntity* enemy_entity;
+        std::shared_ptr<mad::core::LocalWorld> world;
+
+    };
+}// namespace mad::core
+
+
+#endif//MAD_ENEMYATTACKCONDITION_HPP

core/event/management/condition/FallCondition.cpp

@@ -0,0 +1,15 @@
+#include "FallCondition.hpp"
+
+
+
+bool mad::core::FallCondition::is_triggered_by(const mad::core::Event &event) {
+    return m_entity->get_linear_velocity().get_y() >= vel;
+}
+std::unordered_set<mad::core::Event::Type> mad::core::FallCondition::triggers() {
+    return {mad::core::Event::Type::WorldUpdate};
+}
+void mad::core::FallCondition::on_start() {
+}
+mad::core::FallCondition::FallCondition(std::shared_ptr<mad::core::LocalWorld> world, mad::core::Entity::Id entity_id, float vel) : m_world(world), m_entity_id(entity_id), vel(vel) {
+    m_entity = cast_to_or_null<PhysicalEntity>(m_world->get_storage().get_entity(m_entity_id));
+}