Merge pull request #96 from ASM-Studios/dev

Dev

Author: Mael-RABOT

docs/protocol.txt

@@ -19,25 +19,28 @@ RFC 9999 et des brouettes - RType Binary Data Transfer Procol (RBDTP)
     data (such as player movement or chat content).
 
     To ensure no extra memory padding is added, all structures are packed.
-    To ensure packet integrity, a CRC32 checksum is included in the header.
 
-    struct Header {
+    class NonTypedQuery {
         RequestType requestType;
+        std::array<char, MAX_PAYLOAD_SIZE> _fill;
     };
 
     template <typename Payload>
-    struct Query {
-        Header header;
+    class TypedQuery {
+        RequestType requestType;
         Payload payload;
+        std::array<char, MAX_PAYLOAD_SIZE - sizeof(Payload)> _fill;
     };
-    
 
-    template <typename Payload>
-    struct Request {
-        uint32_t checksum;
-        Query<Payload> query;
+    NonTypedQuery and TypedQuery are same elements except that TypedQuery has
+    a typed payload.
+
+    class RawRequest {
+        NonTypedQuery query;
     };
 
+    RawRequest is the class used by the socket to send queries.
+
 4. Protocol
 
     ID are to be defined.
@@ -46,110 +49,30 @@ RFC 9999 et des brouettes - RType Binary Data Transfer Procol (RBDTP)
 
         4.1.1. Movement
 
-            Key pressed:
+            Input:
                 - ID: 0x0000
-                - Request: Query<KeyPressed>
-
-        4.1.2. Chat
-
-            Send a message:
-                - ID: 0x0000
-                - Request: Query<SendMessage>
-
-        4.1.3. Ping
-
-            Ping:
-                - ID: 0x0000
-                - Request: Query<Empty>
+                - Request: ecs::component::Input
 
     4.2. Server to Client
 
-        4.2.1. Entity
-
-            Entity updated:
-                - ID: 0x0000
-                - Request: Query<EntityUpdatedRequest>
-
-            Entity destroyed:
-                - ID: 0x0000
-                - Request: Query<EntityDestroyedRequest>
-            
-        4.2.2. Event
-
-            Projectile fired:
-                - ID: 0x0000
-                - Request: Query<ProjectileFiredRequest>
-
-            Collision:
-                - ID: 0x0000
-                - Request: Query<CollisionRequest>
-
-            Powerup spawned:
-                - ID: 0x0000
-                - Request: Query<PowerupSpawnedRequest>
-
-            Powerup collected:
-                - ID: 0x0000
-                - Request: Query<PowerupCollectedRequest>
-            
-            Explosion:
-                - ID: 0x0000
-                - Request: Query<ExplosionRequest>
-
-            Receive a message:
-                - ID: 0x0000
-                - Request: Query<ReceiveMessageRequest>
-
-5. Structures
-
-struct Empty {};
-
-enum StatusCode {
-    OK,
-    KO
-};
-
-struct CreateLobbyRequest {
-    char username[128];
-};
-
-struct CreateLobbyResponse {
-    uint32_t lobbyId;
-};
-
-struct JoinLobbyRequest {
-    char username[128];
-    uint32_t lobbyId;
-};
-
-struct KeyPressedRequest {
-    char key;
-};
-
-using KeyReleasedRequest = KeyPressedRequest;
+        Update player:
+            - ID: 0x0000
+            - Request: UpdatePlayer
 
-struct SendMessageRequest {
-    char message[256];
-};
+        Update team player:
+            - ID: 0x0000
+            - Request: UpdateTeamPlayer
 
-struct PingResponse {
-    uint64_t timestamp;
-};
+        Create entity:
+            - ID: 0x0000
+            - Request: CreateEntity
 
-struct EntityCreatedRequest {
-    uint32_t entityId;
-    uint32_t x;
-    uint32_t y;
-};
+        Update entity:
+            - ID: 0x0000
+            - Request: UpdateEntity
 
-struct EntityDestroyedRequest {
-    uint32_t entityId;
-};
+        Destroy entity:
+            - ID: 0x0000
+            - Request: DestroyEntity
 
-struct EntityUpdatedRequest {
-    uint32_t entityId;
-    uint32_t x;
-    uint32_t y;
-};
 
-// TO BE CONTINUED

shared/ECS/include/Registry.inl

@@ -5,12 +5,18 @@
 #include <unordered_map>
 
 namespace ecs {
+    /**
+     *  \brief Create an entity with a unique ID.
+     */
     template <typename... Components>
     Entity Registry::createEntity() {
         int id = this->_generateID();
         return this->createEntity(id);
     }
 
+    /**
+     *  \brief Create an entity with a specific ID.
+     */
     template <typename... Components>
     Entity Registry::createEntity(uint64_t id) {
         std::lock_guard<std::mutex> lock(this->_mutex);
@@ -25,6 +31,9 @@ namespace ecs {
         return entity;
     }
 
+    /**
+     *  \brief Get all entities with component.
+     */
     template <typename Component>
     std::unordered_map<Entity, Component> Registry::getEntities() {
         std::lock_guard<std::mutex> lock(this->_mutex);
@@ -35,34 +44,56 @@ namespace ecs {
         return castedMap;
     }
 
+    /**
+     *  \brief Add a component to an entity.
+     */
     template <typename Component>
     void Registry::addComponent(const Entity& entity) {
         std::lock_guard<std::mutex> lock(this->_mutex);
         _components[typeid(Component)][entity] = Component();
     }
 
+    /**
+     *  \brief Add multiple components to an entity.
+     */
     template <typename... Components>
     void Registry::addComponents(const Entity& entity) {
         (addComponent<Components>(entity), ...);
     }
 
+    /**
+     *  \brief Set a component to an entity.
+     *
+     *  Set a component to an entity. If the entity already has a component of the same type, it will be replaced.
+     *  If the entity does not have a component of the same type, it will be added.
+     */
     template <typename Component>
     void Registry::setComponent(const Entity& entity, Component component) {
         std::lock_guard<std::mutex> lock(this->_mutex);
         _components[typeid(Component)][entity] = component;
     }
 
+    /**
+     *  \brief Check if an entity has a component.
+     */
     template <typename Component>
     bool Registry::contains(const Entity& entity) {
         std::lock_guard<std::mutex> lock(this->_mutex);
         return _components[typeid(Component)].contains(entity);
     }
 
+    /**
+     *  \brief Check if an entity has a component with a specific value.
+     */
     template <typename Component>
     bool Registry::contains(const Entity& entity, const Component& component) {
         return this->contains<Component>(entity) && getComponent<Component>(entity) == component;
     }
 
+    /**
+     *  \brief Get a component from an entity.
+     *  \throws ComponentNotFound if the entity does not have the component.
+     */
     template <typename Component>
     Component& Registry::getComponent(const Entity& entity) {
         if (!contains<Component>(entity)) {

shared/ECS/src/Registry.cpp

@@ -20,6 +20,9 @@ namespace ecs {
         return this->_message.c_str();
     }
 
+    /**
+     *  \brief Generate a unique ID for an entity.
+     */
     int Registry::_generateID() {
         std::lock_guard<std::mutex> lock(this->_mutex);
         int id = 1;
@@ -29,14 +32,23 @@ namespace ecs {
         return id;
     }
 
+    /**
+     *  \brief Create a registry with a unique ID.
+     */
     Registry::Registry(uint8_t id) :
         _id(id) {}
 
+    /**
+     *  \brief Get all entities of the registry.
+     */
     std::set<Entity> Registry::getEntities() {
         std::lock_guard<std::mutex> lock(this->_mutex);
         return _entities;
     }
 
+    /**
+     *  \brief Get number of components of an entity.
+     */
     std::size_t Registry::getNoComponent(const Entity& entity) {
         std::lock_guard<std::mutex> lock(this->_mutex);
         std::size_t noComponent = 0;
@@ -48,19 +60,28 @@ namespace ecs {
         return noComponent;
     }
 
+    /**
+     *  \brief Remove all components of an entity.
+     */
     void Registry::reset(const Entity& entity) {
         std::lock_guard<std::mutex> lock(this->_mutex);
         for (auto& component: this->_components) {
             component.second.erase(entity);
         }
     }
 
+    /**
+     *  \brief Remove all entities and components.
+     */
     void Registry::resetAll() {
         std::lock_guard<std::mutex> lock(this->_mutex);
         std::erase_if(this->_components, [this](const auto& item) { return !(item.first == typeid(ecs::component::Player)); });
         std::erase_if(this->_entities, [this](const auto& item) { return getNoComponent(item) == 0; });
     }
 
+    /**
+     *  \brief Remove an entity and its components.
+     */
     void Registry::removeEntity(const Entity& entity) {
         std::lock_guard<std::mutex> lock(this->_mutex);
         _entities.erase(entity);
@@ -69,6 +90,9 @@ namespace ecs {
         }
     }
 
+    /**
+     *  \brief Check if an entity is present in registry.
+     */
     bool Registry::isEntityValid(const Entity& entity) {
         std::lock_guard<std::mutex> lock(this->_mutex);
         return _entities.contains(entity);

shared/GameLogic/src/BehaviorFunc.cpp

@@ -12,6 +12,13 @@
 
 constexpr auto SPEED = 400;
 
+/**
+ * @brief Update the bullet position
+ *
+ * @param mode The game logic mode
+ * @param bullet The bullet entity
+ * @param timePerTick The time per tick
+ */
 void BehaviorFunc::updateBullet(GameLogicMode mode, const ecs::Entity& bullet, float timePerTick) {
     ecs::Registry& registry = ecs::RegistryManager::getInstance().getRegistry();
     int16_t speed = SPEED * 10 * timePerTick;
@@ -24,6 +31,13 @@ void BehaviorFunc::updateBullet(GameLogicMode mode, const ecs::Entity& bullet, f
     }
 }
 
+/**
+ * @brief Update the player sprite sheet from input
+ *
+ * @param mode The game logic mode
+ * @param player The player entity
+ * @param timePerTick The time per tick
+ */
 void BehaviorFunc::setSpriteSheetFromInput(GameLogicMode mode, const ecs::Entity& entity, float deltaTime) {
     ecs::Registry& registry = ecs::RegistryManager::getInstance().getRegistry();
     auto& input = registry.getComponent<ecs::component::Input>(entity);
@@ -66,6 +80,11 @@ void BehaviorFunc::setSpriteSheetFromInput(GameLogicMode mode, const ecs::Entity
     }
 }
 
+/**
+ * @brief Send a bullet to all clients
+ *
+ * @param entity The entity that shot the bullet
+ */
 static void sendBullet(const ecs::Entity& entity) {
     for (const auto& [destEntity, destClient]: ecs::RegistryManager::getInstance().getRegistry().getEntities<network::Client>()) {
         const ecs::Entity& bullet = EntitySchematic::createBullet(entity);
@@ -79,6 +98,13 @@ static void sendBullet(const ecs::Entity& entity) {
     }
 }
 
+/**
+ * @brief Handle the input of the player
+ *
+ * @param mode The game logic mode
+ * @param entity The player entity
+ * @param timePerTick The time per tick
+ */
 void BehaviorFunc::handleInput(GameLogicMode mode, const ecs::Entity& entity, float timePerTick) {
     ecs::Registry& registry = ecs::RegistryManager::getInstance().getRegistry();
     auto& input = registry.getComponent<ecs::component::Input>(entity);