Merge pull request #93 from G-Epitech/rtp-90-document-existing-zygarde-components-and-systems

RTP-90 - Document existing zygarde components and systems

Author: TekMath

docs/docs/dev/libraries/zygarde/core/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "Core",
+  "position": 2,
+  "link": {
+    "type": "generated-index"
+  }
+}

docs/docs/dev/libraries/zygarde/core/archetypes/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "Archetypes",
+  "position": 2,
+  "link": {
+    "type": "generated-index"
+  }
+}

docs/docs/dev/libraries/zygarde/core/archetypes/manager.mdx

@@ -0,0 +1,122 @@
+---
+sidebar_position: 1
+---
+# Manager
+
+
+The `ArchetypeManager` in the `zygarde::core::archetypes` namespace manages the loading, invocation, and scheduling of archetypes in the game engine. Archetypes are JSON-based configurations that define sets of components for game entities, including properties, behavior scripts, and metadata.
+
+```cpp
+namespace zygarde::core::archetypes {
+class ArchetypeManager final {
+  // Member functions and members described below
+};
+}  // namespace zygarde::core::archetypes
+```
+
+### Overview
+The ArchetypeManager class is responsible for:
+
+- Loading archetypes from specified directories.
+- Invoking archetypes to spawn entities based on archetype configurations.
+- Scheduling invocations to defer the spawning of entities to a later time.
+
+Archetypes define the initial properties and behaviors of entities. Here is an example of an archetype configuration in JSON:
+
+```json
+{
+  "archetype_name": "enemy_pata_normal",
+  "components": [
+    {
+      "name": "rigidbody2d",
+      "data": {
+        "isKinematic": false,
+        "drag": 0
+      }
+    },
+    {
+      "name": "position"
+    },
+    {
+      "name": "box_collider2d",
+      "data": {
+        "size": {
+          "x": 52.5,
+          "y": 60
+        },
+        "collisionLayers": [2],
+        "includeLayers": [1, 8]
+      }
+    },
+    {
+      "name": "tags",
+      "data": {
+        "tags": ["enemy", "pata"]
+      }
+    },
+    {
+      "name": "script_pool",
+      "data": [
+        {
+          "scriptName": "pataScript",
+          "customValues": {
+            "health": 30.0,
+            "verticalSpeed": 20.0,
+            "horizontalSpeed": 80.0,
+            "upperLimitOffset": 30.0,
+            "lowerLimitOffset": 30.0,
+            "fireRate": 0.8,
+            "bulletsType": 0,
+            "scoreIncrease": 100
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+### Usage
+
+Here is a usage example for the archetype manager
+```cpp
+#include "archetype_manager.hpp"
+#include "registry.hpp"
+
+int main() {
+    using namespace zygarde::core::archetypes;
+
+    // Initialize ArchetypeManager and Registry
+    ArchetypeManager archetypeManager;
+    auto registry = std::make_shared<zygarde::Registry>();
+
+    // Load archetypes from a directory
+    archetypeManager.LoadArchetypes("path/to/archetypes", scriptsRegistry);
+
+    // Directly invoke an archetype to create an entity
+    zygarde::Entity enemy = archetypeManager.InvokeArchetype(registry, "enemy_pata_normal");
+
+    // Schedule an invocation
+    ArchetypeManager::ScheduleInvocationParams params {
+        .archetypeName = "enemy_pata_normal",
+        .registryAttachCallback = [](const std::shared_ptr<zygarde::Registry>& reg, zygarde::Entity entity) {
+            // Custom behavior after attaching entity to registry
+            std::cout << "Entity created and attached to registry\n";
+        }
+    };
+    archetypeManager.ScheduleInvocation(params);
+
+    // Execute scheduled invocations
+    archetypeManager.ExecuteScheduledInvocations(registry);
+
+    return 0;
+}
+```
+
+Generally prefer using the later invocation when inside the scripting loop and immediate invocation outside of it.
+
+### See Also
+
+- Registry
+- Entity
+- ArchetypeLoader

docs/docs/dev/libraries/zygarde/core/components/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "Components",
+  "position": 1,
+  "link": {
+    "type": "generated-index"
+  }
+}

docs/docs/dev/libraries/zygarde/core/components/positiion.mdx

@@ -0,0 +1,21 @@
+---
+sidebar_position: 1
+---
+
+# Position
+
+The `Position` component is part of the `zygarde::core::components` namespace and represents the spatial location and alignment of a 3D object within the system. It consists of a 3D point vector and an `Alignment` struct to handle horizontal and vertical alignment.
+
+## Overview
+
+The `Position` component allows for the specification of both a 3D position and customizable alignment options (horizontal and vertical), useful for positioning objects within a scene or UI.
+
+```cpp
+namespace zygarde::core::components {
+
+struct Position {
+  core::types::Vector3f point;  ///< Position point
+  Alignment aligns;             ///< Aligns
+};
+
+}  // namespace zygarde::core::components

docs/docs/dev/libraries/zygarde/core/components/tags.mdx

@@ -0,0 +1,7 @@
+---
+sidebar_position: 2
+---
+# Tags
+
+
+The `Tags` component in the `zygarde::core::components` namespace is a utility for managing sets of tags, implemented as a wrapper around a `std::set` of strings. This class provides methods for adding, removing, and querying tags, making it ideal for tagging systems within the `zygarde` library.

docs/docs/dev/libraries/zygarde/core/components/transform.mdx

@@ -0,0 +1,6 @@
+---
+sidebar_position: 3
+---
+# Transform
+
+The `Transform` component in the `zygarde::core::components` namespace represents the scale and rotation properties of a 3D object. This component uses two 3D vectors (`scale` and `rotation`) for defining an object's transformation attributes within the `zygarde` framework.

docs/docs/dev/libraries/zygarde/physics/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "Physics",
+  "position": 1,
+  "link": {
+    "type": "generated-index"
+  }
+}

docs/docs/dev/libraries/zygarde/physics/components/_category_.json

@@ -0,0 +1,7 @@
+{
+  "label": "Components",
+  "position": 1,
+  "link": {
+    "type": "generated-index"
+  }
+}

docs/docs/dev/libraries/zygarde/physics/components/boxcollider.mdx

@@ -0,0 +1,40 @@
+---
+sidebar_position: 2
+---
+# BoxCollider2D
+
+The `BoxCollider2D` class is part of the `zygarde::physics::components` namespace and is designed to represent a 2D box-shaped collider within the physics engine. It provides methods to manage collision detection and response for rectangular objects.
+
+## Overview
+
+`BoxCollider2D` is a final class that allows the definition and manipulation of a 2D box collider. It holds data about the size of the collider and supports specifying collision and inclusion layers to manage how collisions are detected with other objects.
+
+## Properties
+- ``size``: A ``Vector2f`` representing the width and height of the box collider.
+- ``collision_layers``: A vector of integers specifying the collision layers the box collider is considered part of.
+- ``include_layers``: A vector of integers specifying the inclusion layers for the collider, these are the layers the collider will check against.
+
+## Example Usage
+```cpp
+#include "box_collider_2_d.hpp"
+
+using namespace zygarde::physics::components;
+
+core::types::Vector2f boxSize(50.0f, 100.0f);
+std::vector<int> collisionLayers = {1, 2};
+std::vector<int> includeLayers = {1};
+
+// Creating a BoxCollider2D with size and collision layers
+BoxCollider2D collider(boxSize, collisionLayers, includeLayers);
+
+// Set a new size
+collider.SetSize(core::types::Vector2f(60.0f, 120.0f));
+
+//> For the collider to be filled with collisions it needs to run through the collision system
+
+// Check for collisions
+if (collider.HasCollision()) {
+    auto collision = collider.GetNextCollision();
+    // Process collision
+}
+```