Added more comments and fixed some warnings

Author: billy1arm

src/game/Maps/MapUpdater.cpp

@@ -30,51 +30,80 @@
 #include <ace/Guard_T.h>
 #include <ace/Method_Request.h>
 
+/**
+ * @brief A request to update a map.
+ */
 class MapUpdateRequest : public ACE_Method_Request
 {
     private:
-
-        Map& m_map;
-        MapUpdater& m_updater;
-        ACE_UINT32 m_diff;
+        Map& m_map; ///< Reference to the map to be updated.
+        MapUpdater& m_updater; ///< Reference to the map updater.
+        ACE_UINT32 m_diff; ///< Time difference for the update.
 
     public:
-
+        /**
+         * @brief Constructor for MapUpdateRequest.
+         * @param m Reference to the map.
+         * @param u Reference to the map updater.
+         * @param d Time difference for the update.
+         */
         MapUpdateRequest(Map& m, MapUpdater& u, ACE_UINT32 d)
             : m_map(m), m_updater(u), m_diff(d)
         {
         }
 
+        /**
+         * @brief Executes the map update request.
+         * @return Always returns 0.
+         */
         virtual int call()
         {
-            m_map.Update (m_diff);
+            m_map.Update(m_diff);
             m_updater.update_finished();
             return 0;
         }
 };
 
+/**
+ * @brief Constructor for MapUpdater.
+ */
 MapUpdater::MapUpdater():
 m_executor(), m_mutex(), m_condition(m_mutex), pending_requests(0)
 {
 }
 
+/**
+ * @brief Destructor for MapUpdater.
+ */
 MapUpdater::~MapUpdater()
 {
     deactivate();
 }
 
+/**
+ * @brief Activates the map updater with the specified number of threads.
+ * @param num_threads Number of threads to activate.
+ * @return Result of the activation.
+ */
 int MapUpdater::activate(size_t num_threads)
 {
     return m_executor._activate((int)num_threads);
 }
 
+/**
+ * @brief Deactivates the map updater.
+ * @return Result of the deactivation.
+ */
 int MapUpdater::deactivate()
 {
     wait();
-
     return m_executor.deactivate();
 }
 
+/**
+ * @brief Waits for all pending requests to be processed.
+ * @return Always returns 0.
+ */
 int MapUpdater::wait()
 {
     ACE_GUARD_RETURN(ACE_Thread_Mutex, guard, m_mutex, -1);
@@ -85,6 +114,12 @@ int MapUpdater::wait()
     return 0;
 }
 
+/**
+ * @brief Schedules a map update.
+ * @param map Reference to the map to be updated.
+ * @param diff Time difference for the update.
+ * @return Result of the scheduling.
+ */
 int MapUpdater::schedule_update(Map& map, ACE_UINT32 diff)
 {
     ACE_GUARD_RETURN(ACE_Thread_Mutex, guard, m_mutex, -1);
@@ -102,11 +137,18 @@ int MapUpdater::schedule_update(Map& map, ACE_UINT32 diff)
     return 0;
 }
 
+/**
+ * @brief Checks if the map updater is activated.
+ * @return True if activated, false otherwise.
+ */
 bool MapUpdater::activated()
 {
     return m_executor.activated();
 }
 
+/**
+ * @brief Called when a map update is finished.
+ */
 void MapUpdater::update_finished()
 {
     ACE_GUARD(ACE_Thread_Mutex, guard, m_mutex);
@@ -120,4 +162,4 @@ void MapUpdater::update_finished()
     --pending_requests;
 
     m_condition.broadcast();
-}
+}

src/game/Maps/MapUpdater.h

@@ -32,33 +32,67 @@
 
 class Map;
 
+/**
+ * @brief The MapUpdater class is responsible for managing map update requests.
+ */
 class MapUpdater
 {
     public:
-
+        /**
+         * @brief Constructor for MapUpdater.
+         */
         MapUpdater();
+
+        /**
+         * @brief Destructor for MapUpdater.
+         */
         virtual ~MapUpdater();
 
         friend class MapUpdateRequest;
 
+        /**
+         * @brief Schedules a map update.
+         * @param map Reference to the map to be updated.
+         * @param diff Time difference for the update.
+         * @return Result of the scheduling.
+         */
         int schedule_update(Map& map, ACE_UINT32 diff);
 
+        /**
+         * @brief Waits for all pending requests to be processed.
+         * @return Always returns 0.
+         */
         int wait();
 
+        /**
+         * @brief Activates the map updater with the specified number of threads.
+         * @param num_threads Number of threads to activate.
+         * @return Result of the activation.
+         */
         int activate(size_t num_threads);
 
+        /**
+         * @brief Deactivates the map updater.
+         * @return Result of the deactivation.
+         */
         int deactivate();
 
+        /**
+         * @brief Checks if the map updater is activated.
+         * @return True if activated, false otherwise.
+         */
         bool activated();
 
     private:
-
-        DelayExecutor m_executor;
-        ACE_Thread_Mutex m_mutex;
-        ACE_Condition_Thread_Mutex m_condition;
-        size_t pending_requests;
-
+        DelayExecutor m_executor; ///< Executor for handling delayed tasks.
+        ACE_Thread_Mutex m_mutex; ///< Mutex for synchronizing access to pending requests.
+        ACE_Condition_Thread_Mutex m_condition; ///< Condition variable for signaling when requests are processed.
+        size_t pending_requests; ///< Number of pending update requests.
+
+        /**
+         * @brief Called when a map update is finished.
+         */
         void update_finished();
 };
 
-#endif //_MAP_UPDATER_H_INCLUDED
+#endif //_MAP_UPDATER_H_INCLUDED

src/game/MotionGenerators/ConfusedMovementGenerator.cpp

@@ -28,12 +28,16 @@
 #include "movement/MoveSplineInit.h"
 #include "movement/MoveSpline.h"
 
+/**
+ * @brief Initializes the ConfusedMovementGenerator.
+ * @param unit Reference to the unit.
+ */
 template<class T>
 void ConfusedMovementGenerator<T>::Initialize(T& unit)
 {
     unit.addUnitState(UNIT_STAT_CONFUSED);
 
-    // set initial position
+    // Set initial position
     unit.GetPosition(i_x, i_y, i_z);
 
     if (!unit.IsAlive() || unit.hasUnitState(UNIT_STAT_NOT_MOVE))
@@ -45,14 +49,22 @@ void ConfusedMovementGenerator<T>::Initialize(T& unit)
     unit.addUnitState(UNIT_STAT_CONFUSED_MOVE);
 }
 
+/**
+ * @brief Interrupts the ConfusedMovementGenerator.
+ * @param unit Reference to the unit.
+ */
 template<class T>
 void ConfusedMovementGenerator<T>::Interrupt(T& unit)
 {
     unit.InterruptMoving();
-    // confused state still applied while movegen disabled
+    // Confused state still applied while movegen disabled
     unit.clearUnitState(UNIT_STAT_CONFUSED_MOVE);
 }
 
+/**
+ * @brief Resets the ConfusedMovementGenerator.
+ * @param unit Reference to the unit.
+ */
 template<class T>
 void ConfusedMovementGenerator<T>::Reset(T& unit)
 {
@@ -67,18 +79,24 @@ void ConfusedMovementGenerator<T>::Reset(T& unit)
     unit.addUnitState(UNIT_STAT_CONFUSED | UNIT_STAT_CONFUSED_MOVE);
 }
 
+/**
+ * @brief Updates the ConfusedMovementGenerator.
+ * @param unit Reference to the unit.
+ * @param diff Time difference.
+ * @return True if the update was successful, false otherwise.
+ */
 template<class T>
 bool ConfusedMovementGenerator<T>::Update(T& unit, const uint32& diff)
 {
-    // ignore in case other no reaction state
+    // Ignore in case other no reaction state
     if (unit.hasUnitState(UNIT_STAT_CAN_NOT_REACT & ~UNIT_STAT_CONFUSED))
     {
         return true;
     }
 
     if (i_nextMoveTime.Passed())
     {
-        // currently moving, update location
+        // Currently moving, update location
         unit.addUnitState(UNIT_STAT_CONFUSED_MOVE);
 
         if (unit.movespline->Finalized())
@@ -88,51 +106,62 @@ bool ConfusedMovementGenerator<T>::Update(T& unit, const uint32& diff)
     }
     else
     {
-        // waiting for next move
+        // Waiting for next move
         i_nextMoveTime.Update(diff);
         if (i_nextMoveTime.Passed())
         {
-            // start moving
+            // Start moving
             unit.addUnitState(UNIT_STAT_CONFUSED_MOVE);
 
             float destX = i_x;
             float destY = i_y;
             float destZ = i_z;
 
-            // check if new random position is assigned, GetReachableRandomPosition may fail
+            // Check if new random position is assigned, GetReachableRandomPosition may fail
             if (unit.GetMap()->GetReachableRandomPosition(&unit, destX, destY, destZ, 10.0f))
             {
                 Movement::MoveSplineInit init(unit);
                 init.MoveTo(destX, destY, destZ, true);
                 init.SetWalk(true);
                 init.Launch();
-                i_nextMoveTime.Reset(urand(800, 1000));             // Keep a short wait time
+                i_nextMoveTime.Reset(urand(800, 1000)); // Keep a short wait time
             }
             else
             {
-                i_nextMoveTime.Reset(50);                           // Retry later
+                i_nextMoveTime.Reset(50); // Retry later
             }
         }
     }
 
     return true;
 }
 
+/**
+ * @brief Finalizes the ConfusedMovementGenerator for a Player.
+ * @param unit Reference to the player.
+ */
 template<>
 void ConfusedMovementGenerator<Player>::Finalize(Player& unit)
 {
     unit.clearUnitState(UNIT_STAT_CONFUSED | UNIT_STAT_CONFUSED_MOVE);
     unit.StopMoving(true);
 }
 
+/**
+ * @brief Finalizes the ConfusedMovementGenerator for a Creature.
+ * @param unit Reference to the creature.
+ */
 template<>
 void ConfusedMovementGenerator<Creature>::Finalize(Creature& unit)
 {
     unit.clearUnitState(UNIT_STAT_CONFUSED | UNIT_STAT_CONFUSED_MOVE);
 }
 
+// Template instantiations for Player and Creature
 template void ConfusedMovementGenerator<Player>::Initialize(Player& player);
 template void ConfusedMovementGenerator<Creature>::Initialize(Creature& creature);
+template void ConfusedMovementGenerator<Player>::Finalize(Player& player);
+template void ConfusedMovementGenerator<Creature>::Finalize(Creature& creature);
 template void ConfusedMovementGenerator<Player>::Interrupt(Player& player);
 template void ConfusedMovementGenerator<Creature>::Interrupt(Creature& creature);
 template void ConfusedMovementGenerator<Player>::Reset(Player& player);