Merge pull request #80 from X-R-G-B/fix/missing-network-send-calls

Fix/missing network send calls

src/Client/Systems/Graphic/AudioSystems.cpp

@@ -8,11 +8,13 @@
 #include "AudioSystems.hpp"
 #include "CustomTypes.hpp"
 #include "Raylib.hpp"
+#include "Registry.hpp"
 #include "SystemManagersDirector.hpp"
 
 namespace Systems {
     void GraphicSystems::soundEffectPlayer(std::size_t /*unused*/, std::size_t /*unused*/)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         Registry::components<Raylib::Sound> arrSoundEffect =
             Registry::getInstance().getComponents<Raylib::Sound>();
 
@@ -26,6 +28,7 @@ namespace Systems {
 
     void GraphicSystems::musicPlayer(std::size_t /*unused*/, std::size_t /*unused*/)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         Registry::components<Raylib::Music> arrMusics =
             Registry::getInstance().getComponents<Raylib::Music>();
 
@@ -45,6 +48,7 @@ namespace Systems {
 
     void GraphicSystems::playSoundWithKey(std::size_t /*unused*/, std::size_t /*unused*/)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         Registry &registry                            = Registry::getInstance();
         Registry::components<Raylib::Music> arrMusics = registry.getComponents<Raylib::Music>();
         Registry::components<Raylib::Sound> arrSounds = registry.getComponents<Raylib::Sound>();

src/Client/Systems/Graphic/DeathSystems.cpp

@@ -14,6 +14,7 @@
 namespace Systems {
 
     const std::function<void(std::size_t)> setPlayerAnimRectDeath = [](std::size_t id) {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         Registry::components<Types::AnimRect> arrAnimRect =
             Registry::getInstance().getComponents<Types::AnimRect>();
 

src/Client/Systems/Graphic/GraphicSystems.cpp

@@ -19,6 +19,7 @@ namespace Systems {
 #ifndef NDEBUG
     void debugCollisionRect(std::size_t /*unused*/, std::size_t /*unused*/)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         Registry::components<Types::CollisionRect> arrCollisionRect =
             Registry::getInstance().getComponents<Types::CollisionRect>();
         Registry::components<Types::Position> arrPosition =

src/Client/Systems/Graphic/ParallaxSystems.cpp

@@ -90,6 +90,7 @@ namespace Systems::ParallaxSystems {
 
     void manageParallax(std::size_t /*unused*/, std::size_t /*unused*/)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         Registry::components<Types::Position> arrPosition =
             Registry::getInstance().getComponents<Types::Position>();
         Registry::components<Types::Parallax> arrParallax =

src/Client/Systems/Graphic/SpriteSystems.cpp

@@ -7,6 +7,7 @@
 
 #include "SpriteSystems.hpp"
 #include "CustomTypes.hpp"
+#include "ECSCustomTypes.hpp"
 #include "Logger.hpp"
 #include "Raylib.hpp"
 #include "SharedValues.hpp"
@@ -206,8 +207,39 @@ namespace Systems {
         }
     }
 
+    void GraphicSystems::createSprite(std::size_t /*unused*/, std::size_t /*unused*/)
+    {
+        auto &arrSpriteDatas = Registry::getInstance().getComponents<Types::PlayerDatas>();
+        auto &arrSprite      = Registry::getInstance().getComponents<Raylib::Sprite>();
+
+        auto ids = arrSpriteDatas.getExistingsId();
+        for (auto id : ids) {
+            auto &spriteDatas = arrSpriteDatas[id];
+            Raylib::Sprite sprite(
+                spriteDatas.fileName,
+                spriteDatas.width,
+                spriteDatas.height,
+                spriteDatas.id);
+            arrSprite.insert(id, sprite);
+            switch (spriteDatas.layer) {
+                case BACKLAYER:
+                    Registry::getInstance().setToBackLayers(
+                        id,
+                        static_cast<enum BackLayers>(spriteDatas.layerSide));
+                    break;
+                case FRONTLAYER: Registry::getInstance().setToDefaultLayer(id); break;
+                case DEFAULTLAYER:
+                    Registry::getInstance().setToFrontLayers(
+                        id,
+                        static_cast<enum FrontLayers>(spriteDatas.layerSide));
+                    break;
+            }
+        }
+        arrSpriteDatas.clear();
+    }
+
     std::vector<std::function<void(std::size_t, std::size_t)>> GraphicSystems::getSpriteSystems()
     {
-        return {rectIncrementation, rectRenderer, spriteRenderer};
+        return {rectIncrementation, rectRenderer, spriteRenderer, createSprite};
     }
 } // namespace Systems

src/Client/Systems/Graphic/SpriteSystems.hpp

@@ -16,6 +16,7 @@ namespace Systems {
         void rectIncrementation(std::size_t /*unused*/, std::size_t /*unused*/);
         void rectRenderer(std::size_t /*unused*/, std::size_t /*unused*/);
         void spriteRenderer(std::size_t /*unused*/, std::size_t /*unused*/);
+        void createSprite(std::size_t managerId, std::size_t systemId);
         std::vector<std::function<void(std::size_t, std::size_t)>> getSpriteSystems();
     } // namespace GraphicSystems
 } // namespace Systems

src/Client/Systems/Network/ClientNetwork.cpp

@@ -10,6 +10,7 @@
 namespace Systems {
     void receiveLifeUpdate(std::any &any, boost::asio::ip::udp::endpoint & /* unused */)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         auto msg                                        = std::any_cast<struct msgLifeUpdate_s>(any);
         Registry &registry                              = Registry::getInstance();
         Registry::components<struct health_s> arrHealth = registry.getComponents<struct health_s>();
@@ -27,6 +28,7 @@ namespace Systems {
 
     void receiveEnemyDeath(std::any &any, boost::asio::ip::udp::endpoint &)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         const auto enemyDeath                      = std::any_cast<struct msgEnemyDeath_s>(any);
         Registry::components<Types::Enemy> enemies = Registry::getInstance().getComponents<Types::Enemy>();
         std::vector<std::size_t> ids               = enemies.getExistingsId();
@@ -39,23 +41,26 @@ namespace Systems {
         }
     }
 
-    void receiveEnemyNb(std::any &any, boost::asio::ip::udp::endpoint &)
+    void handleStartWave(std::any &any, boost::asio::ip::udp::endpoint &)
     {
-        const auto enemyNb = std::any_cast<struct msgEnemyNb_s>(any);
-        Types::Enemy::setEnemyNb(enemyNb.enemyNb);
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
+        const auto wave = std::any_cast<struct msgStartWave_s>(any);
+        Types::Enemy::setEnemyNb(wave.enemyNb);
         SystemManagersDirector::getInstance()
             .getSystemManager(static_cast<std::size_t>(Scene::SystemManagers::GAME))
             .addSystem(initWave);
+        Logger::info("Wave started");
     }
 
     void receivePlayerInit(std::any &any, boost::asio::ip::udp::endpoint &)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         const auto playerInit = std::any_cast<struct msgPlayerInit_s>(any);
-        Registry &registry    = Registry::getInstance();
-        auto &arrPlayer       = registry.getComponents<Types::Player>();
+        auto &arrPlayer       = Registry::getInstance().getComponents<Types::Player>();
 
-        Logger::info("Player id: " + std::to_string(playerInit.playerId));
-        arrPlayer[0].constId = playerInit.playerId;
+        Logger::info("Your player id is: " + std::to_string(playerInit.playerId));
+        initPlayer();
+        arrPlayer[arrPlayer.getExistingsId().at(0)].constId = playerInit.playerId;
     }
 
     const std::string enemyFile = "assets/Json/enemyData.json";
@@ -68,6 +73,7 @@ namespace Systems {
 
     void sendPositionRelative(std::size_t /* unused */, std::size_t /* unused */)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         constexpr std::size_t delay = 10;
         static auto clockId         = Registry::getInstance().getClock().create();
         static std::pair<std::size_t, Types::Position> positionPlayerCached;
@@ -100,6 +106,7 @@ namespace Systems {
 
     void sendPositionAbsolute(std::size_t /* unused */, std::size_t /* unused */)
     {
+        std::lock_guard<std::mutex> lock(Registry::getInstance().mutex);
         constexpr std::size_t delay = 1;
         static auto clockId         = Registry::getInstance().getClock().create();
         Registry &registry          = Registry::getInstance();

src/Client/Systems/Network/ClientNetwork.hpp

@@ -7,7 +7,7 @@
 namespace Systems {
     void receiveLifeUpdate(std::any &any, boost::asio::ip::udp::endpoint &endpoint);
     void receiveEnemyDeath(std::any &any, boost::asio::ip::udp::endpoint &endpoint);
-    void receiveEnemyNb(std::any &any, boost::asio::ip::udp::endpoint &);
+    void handleStartWave(std::any &any, boost::asio::ip::udp::endpoint &);
     void receivePlayerInit(std::any &any, boost::asio::ip::udp::endpoint &endpoint);
     void receiveNewEnemy(std::any &any, boost::asio::ip::udp::endpoint &);
     void sendPositionRelative(std::size_t /* unused */, std::size_t /* unused */);

src/ECS/ECSCustomTypes.hpp

@@ -16,6 +16,7 @@ extern "C"
 {
 #include "MessageTypes.h"
 }
+#include "Registry.hpp"
 
 // all values are in percentage of the screen
 namespace Types {
@@ -50,6 +51,30 @@ namespace Types {
             NLOHMANN_DEFINE_TYPE_INTRUSIVE(Velocity, speedX, speedY);
     };
 
+    struct PlayerDatas {
+            PlayerDatas(
+                const std::string &fileName,
+                float width,
+                float height,
+                std::size_t id,
+                enum LayerType layer,
+                std::size_t layerSide)
+                : fileName(fileName),
+                  width(width),
+                  height(height),
+                  id(id),
+                  layer(layer),
+                  layerSide(layerSide)
+            {
+            }
+            std::string fileName;
+            float width;
+            float height;
+            std::size_t id;
+            enum LayerType layer;
+            size_t layerSide;
+    };
+
     struct Player {
             unsigned int constId;
     };
@@ -99,6 +124,13 @@ namespace Types {
                 _enemyNb = nb;
             }
 
+            static unsigned int getEnemyNb()
+            {
+                std::lock_guard<std::mutex> lock(_mutex);
+
+                return _enemyNb;
+            }
+
         private:
             enemy_id_s _constId;
             static unsigned int _enemyNb;

src/ECS/Registry.hpp

@@ -10,6 +10,7 @@
 #include <any>
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <stdexcept>
 #include <string>
 #include <typeindex>
@@ -78,6 +79,8 @@ class Registry {
 
         Logger::Logger &getLogger();
 
+        std::mutex mutex;
+
     private:
         Registry();
 

src/ECS/SparseArray.hpp

@@ -99,6 +99,17 @@ class SparseArray {
             return _revSparse;
         }
 
+        void clear()
+        {
+            _dense.clear();
+            for (auto it = _sparse.begin(); it != _sparse.end(); it++) {
+                if (static_cast<int>(*it) > -1) {
+                    (*it) = static_cast<std::size_t>(-1);
+                }
+            }
+            _revSparse.clear();
+        }
+
     private:
         void removeDenses(std::size_t sparseValue)
         {
@@ -118,7 +129,8 @@ class SparseArray {
         void throwIfDontExist(std::size_t id)
         {
             if (!exist(id)) {
-                throw std::runtime_error("SparseArrays: ID out of bounds!");
+                throw std::runtime_error(
+                    "SparseArrays: ID out of bounds! (id: " + std::to_string(id) + ")");
             }
         }
 

src/ECS/Systems/Managers/SystemManager.cpp

@@ -7,6 +7,7 @@
 
 #include "SystemManager.hpp"
 #include <algorithm>
+#include "Logger.hpp"
 
 namespace Systems {