Add quadtree doc

src/quadtree.h

@@ -1,6 +1,7 @@
 #include "otpch.h"
 
 #include "creature.h"
+#include "map.h"
 #include "spectators.h"
 
 namespace tfs::map::quadtree {
@@ -31,20 +32,20 @@
  *
  * This class defines the interface for a QuadTree node.
  * The class is non-copyable to prevent accidental copying of nodes.
-*/
+ */
 class QuadTree
 {
 public:
 	/// @brief Default constructor for QuadTree.
 	explicit QuadTree() = default;
 
 	/**
-     * @brief Virtual destructor for QuadTree.
-     * 
-     * The virtual destructor allows for proper cleanup
+	 * @brief Virtual destructor for QuadTree.
+	 *
+	 * The virtual destructor allows for proper cleanup
 	 * of derived classes
-     * that may be allocated dynamically.
-     */
+	 * that may be allocated dynamically.
+	 */
 	virtual ~QuadTree() = default;
 
 	/// Deleted copy constructor to ensure QuadTree is non-copyable.
@@ -53,49 +54,49 @@
 	QuadTree& operator=(const QuadTree&) = delete;
 
 	/**
-     * @brief Check if the node is a leaf node.
-     * @return true if the node is a leaf, false otherwise.
+	 * @brief Check if the node is a leaf node.
+	 * @return true if the node is a leaf, false otherwise.
 	 */
 	virtual bool is_leaf() const = 0;
 
 	/**
-     * @brief Set a child node at a specified index.
-     * 
-     * This method assigns a child node to the
+	 * @brief Set a child node at a specified index.
+	 *
+	 * This method assigns a child node to the
 	 * current node at the given
-     * index. The index must be within valid bounds for child nodes (0 to 3).
+	 * index. The index must be within valid bounds for child nodes (0 to 3).
 	 * @param {index} The index at which to set the child node.
 	 * @param {node} A pointer to the child node to be
 	 * set.
-     */
+	 */
 	virtual void set_child(uint8_t index, QuadTree* node) = 0;
 
 	/**
-     * @brief Get a child node at a specified index.
-     * @param {index} The index of the child node to
+	 * @brief Get a child node at a specified index.
+	 * @param {index} The index of the child node to
 	 * retrieve (0 to 3).
-     * @return A pointer to the child node, or nullptr if no child exists.
-     */
+	 * @return A pointer to the child node, or nullptr if no child exists.
+	 */
 	virtual QuadTree* get_child(uint8_t index) const = 0;
 };
 
 /// The number of bits used to represent the dimensions of a tile grid.
 inline constexpr int32_t TILE_GRID_BITS = 3;
 /// The size of the tile grid, calculated as 2 ^ TILE_GRID_BITS.
 /// This value indicates the number of tiles that can fit along one dimension of the grid.
 inline constexpr int32_t TILE_GRID_SIZE = (1 << TILE_GRID_BITS);
 /// A mask to isolate the tile index within the bounds of the grid size.
 /// This mask is used to ensure tile indices remain valid and wrap around correctly.
 inline constexpr int32_t TILE_INDEX_MASK = (TILE_GRID_SIZE - 1);
 
 /**
-  * @class Node
-  * @brief Represents a node in a QuadTree.
-  * 
-  * This class extends the QuadTree interface and
-  * implements a specific type of node that can have up to four child nodes.
-  */
+ * @class Node
+ * @brief Represents a node in a QuadTree.
+ *
+ * This class extends the QuadTree interface and
+ * implements a specific type of node that can have up to four child nodes.
+ */
 class Node final : public QuadTree
 {
 public:
 	/// @brief Default constructor for QuadTree.
@@ -107,36 +108,36 @@
 	Node& operator=(const Node&) = delete;
 
 	/**
-     * @brief Check if the node is a leaf node.
-     * 
-     * This implementation always returns false, as Node
+	 * @brief Check if the node is a leaf node.
+	 *
+	 * This implementation always returns false, as Node
 	 * objects are designed to have children.
-     * @return false, indicating that the node is not a leaf.
+	 * @return false, indicating that the node is not a leaf.
 	 */
 	bool is_leaf() const override { return false; }
 
 	/**
-     * @brief Set a child node at a specified index.
-     * 
-     * This method assigns a child node to the
+	 * @brief Set a child node at a specified index.
+	 *
+	 * This method assigns a child node to the
 	 * current node at the given index. The index must be in the range of 0 to 3.
-     *
-     * @param {index} The index
+	 *
+	 * @param {index} The index
 	 * at which to set the child node (0 to 3).
-     * @param {node} A pointer to the child QuadTree node to be set.
+	 * @param {node} A pointer to the child QuadTree node to be set.
 	 */
 	void set_child(uint8_t index, QuadTree* node) override { nodes[index] = node; }
 
 	/**
-     * @brief Get a child node at a specified index.
-     * 
-     * This method retrieves the child node at the
+	 * @brief Get a child node at a specified index.
+	 *
+	 * This method retrieves the child node at the
 	 * specified index.
-     *
-     * @param {index} The index of the child node to retrieve (0 to 3).
-     * @return A
+	 *
+	 * @param {index} The index of the child node to retrieve (0 to 3).
+	 * @return A
 	 * pointer to the child QuadTree node, or nullptr if no child exists.
-     */
+	 */
 	QuadTree* get_child(uint8_t index) const override { return nodes[index]; };
 
 private:
@@ -147,19 +148,19 @@
 /**
  * @class Leaf
  * @brief Represents a leaf node in a QuadTree.
- * 
+ *
  * This class extends the QuadTree interface and
  * is designed to hold data specific to a leaf node, such as creatures and tile information.
  */
 class Leaf final : public QuadTree
 {
 public:
 	/**
-     * @brief Constructor for Leaf.
-     * 
-     * This constructor initializes the leaf node with the specified
+	 * @brief Constructor for Leaf.
+	 *
+	 * This constructor initializes the leaf node with the specified
 	 * coordinates.
-     */
+	 */
 	explicit Leaf(uint16_t x, uint16_t y);
 
 	/// Deleted copy constructor to ensure Leaf is non-copyable.
@@ -168,62 +169,62 @@
 	Leaf& operator=(const Leaf&) = delete;
 
 	/**
-     * @brief Check if the node is a leaf node.
-     * 
-     * This implementation always returns true,
+	 * @brief Check if the node is a leaf node.
+	 *
+	 * This implementation always returns true,
 	 * indicating that this object is a leaf.
-     * @return true, indicating that the node is a Leaf.
-     */
+	 * @return true, indicating that the node is a Leaf.
+	 */
 	bool is_leaf() const override { return true; }
 
 	/**
-     * @brief Set a child node at a specified index.
-     * 
-     * This method does nothing, as leaf nodes
+	 * @brief Set a child node at a specified index.
+	 *
+	 * This method does nothing, as leaf nodes
 	 * cannot have children.
-     * @param {index} The index at which to set the child node (not used).
-     * @param
+	 * @param {index} The index at which to set the child node (not used).
+	 * @param
 	 * {node} A pointer to the child node to be set (not used).
-     */
-	void set_child(uint8_t index, QuadTree* node) override {}
+	 */
+	void set_child(uint8_t, QuadTree*) override {}
 
 	/**
-     * @brief Get a child node at a specified index.
-     * 
-     * This method always returns nullptr, as leaf
+	 * @brief Get a child node at a specified index.
+	 *
+	 * This method always returns nullptr, as leaf
 	 * nodes do not have children.
-     * @param {index} The index of the child node to retrieve (not used).
+	 * @param {index} The index of the child node to retrieve (not used).
 	 * @return Always returns nullptr.
-     */
-	QuadTree* get_child(uint8_t index) const override { return nullptr; };
+	 */
+	QuadTree* get_child(uint8_t) const override { return nullptr; };
 
 	/**
-     * @brief Add a creature to the leaf.
-     * 
-     * This method adds the specified creature to the Leaf
+	 * @brief Add a creature to the leaf.
+	 *
+	 * This method adds the specified creature to the Leaf
 	 * node.
-     * @param {creature} A pointer to the creature to be added.
-     */
+	 * @param {creature} A pointer to the creature to be added.
+	 */
 	void push_creature(Creature* creature);
 
 	/**
-     * @brief Remove a creature from the leaf.
-     * 
-     * This method removes the specified creature from
+	 * @brief Remove a creature from the leaf.
+	 *
+	 * This method removes the specified creature from
 	 * the leaf node.
-     * @param {creature} A pointer to the creature to be removed.
+	 * @param {creature} A pointer to the creature to be removed.
 	 */
 	void remove_creature(Creature* creature);
 
 	/**
-     * @brief A 3D array of pointers to tiles for the leaf across multiple layers.
+	 * @brief A 3D array of pointers to tiles for the leaf across multiple layers.
 	 *
 	 *  This array holds pointers to `Tile` objects, organized in a three-dimensional
 	 *  structure. The first dimension represents different layers, while the second
 	 *  and third dimensions represent the x and y coordinates of the tiles within
 	 *  each layer. Each layer can contain a grid of tiles.
-	*/
+	 */
 	std::array<std::array<std::array<Tile*, TILE_GRID_SIZE>, TILE_GRID_SIZE>, MAP_MAX_LAYERS> tiles = {};
 
 	/// @brief A set of creatures (monsters, NPCs and players) present in this leaf node.
 	std::set<Creature*> creatures;