Expand spell methods and add preliminary documentation for the new methods.

Author: Terrorblade

methods/TrinityCore/AuraEffectMethods.h

@@ -10,57 +10,105 @@
 
 namespace LuaAuraEffects
 {
+    /**
+     * Returns the [Aura] that this [AuraEffect] belongs to.
+     *
+     * @return [Aura] base
+     */
     int GetBase(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetBase());
         return 1;
     }
 
+    /**
+     * Returns the base amount of the [AuraEffect].
+     *
+     * @return int32 baseAmount
+     */
     int GetBaseAmount(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetBaseAmount());
         return 1;
     }
 
+    /**
+     * Returns the amplitude in milliseconds of the [AuraEffect].
+     *
+     * @return uint32 amplitude
+     */
     int GetAmplitude(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetAmplitude());
         return 1;
     }
 
+    /**
+     * Returns the current amount of the [AuraEffect].
+     *
+     * @return int32 amount
+     */
     int GetAmount(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetAmount());
         return 1;
     }
 
+    /**
+     * Sets the amount of the [AuraEffect].
+     *
+     * @param int32 amount : the amount to set
+     */
     int SetAmount(Eluna* E, AuraEffect* aurEff)
     {
         int32 amount = E->CHECKVAL<int32>(2);
         aurEff->SetAmount(amount);
         return 0;
     }
 
+    /**
+     * Returns the remaining time in milliseconds until the next tick of the [AuraEffect].
+     *
+     * @return int32 periodicTimer
+     */
     int GetPeriodicTimer(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetPeriodicTimer());
         return 1;
     }
 
+    /**
+     * Sets the periodic timer of the [AuraEffect].
+     *
+     * @param int32 timer : the timer value in milliseconds to set
+     */
     int SetPeriodicTimer(Eluna* E, AuraEffect* aurEff)
     {
         int32 timer = E->CHECKVAL<int32>(2);
         aurEff->SetPeriodicTimer(timer);
         return 0;
     }
 
+    /**
+     * Calculates and returns the amount of the [AuraEffect] for the given caster.
+     *
+     * @param [Unit] caster : the caster to calculate the amount for
+     * @return int32 amount
+     */
     int CalculateAmount(Eluna* E, AuraEffect* aurEff)
     {
         Unit* caster = E->CHECKOBJ<Unit>(2);
         E->Push(aurEff->CalculateAmount(caster));
         return 1;
     }
 
+    /**
+     * Calculates the periodic properties of the [AuraEffect] for the given caster.
+     *
+     * @param [Unit] caster : the caster to calculate for
+     * @param bool resetPeriodicTimer = false : whether to reset the periodic timer
+     * @param bool load = false : whether this is being loaded from the database
+     */
     int CalculatePeriodic(Eluna* E, AuraEffect* aurEff)
     {
         Unit* caster = E->CHECKOBJ<Unit>(2);
@@ -70,6 +118,13 @@ namespace LuaAuraEffects
         return 0;
     }
 
+    /**
+     * Changes the amount of the [AuraEffect].
+     *
+     * @param int32 newAmount : the new amount to set
+     * @param bool mark = true : whether to mark the effect as changed
+     * @param bool onStackOrReapply = false : whether this change is due to a stack or reapply
+     */
     int ChangeAmount(Eluna* E, AuraEffect* aurEff)
     {
         int32 newAmount = E->CHECKVAL<int32>(2);
@@ -79,43 +134,76 @@ namespace LuaAuraEffects
         return 0;
     }
 
+    /**
+     * Recalculates the amount of the [AuraEffect].
+     */
     int RecalculateAmount(Eluna* /*E*/, AuraEffect* aurEff)
     {
         aurEff->RecalculateAmount();
         return 0;
     }
 
+    /**
+     * Returns `true` if the [AuraEffect] amount can be recalculated, `false` otherwise.
+     *
+     * @return bool canBeRecalculated
+     */
     int CanBeRecalculated(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->CanBeRecalculated());
         return 1;
     }
 
+    /**
+     * Sets whether the [AuraEffect] amount can be recalculated.
+     *
+     * @param bool val = true : set to 'true' to allow recalculation
+     */
     int SetCanBeRecalculated(Eluna* E, AuraEffect* aurEff)
     {
         bool val = E->CHECKVAL<bool>(2, true);
         aurEff->SetCanBeRecalculated(val);
         return 0;
     }
 
+    /**
+     * Returns the current tick number of the [AuraEffect].
+     *
+     * @return uint32 tickNumber
+     */
     int GetTickNumber(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetTickNumber());
         return 1;
     }
 
+    /**
+     * Returns the number of remaining ticks of the [AuraEffect].
+     *
+     * @return uint32 remainingTicks
+     */
     int GetRemainingTicks(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetRemainingTicks());
         return 1;
     }
 
+    /**
+     * Returns the total number of ticks of the [AuraEffect].
+     *
+     * @return uint32 totalTicks
+     */
     int GetTotalTicks(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetTotalTicks());
         return 1;
     }
 
+    /**
+     * Returns a table of all [Unit]s currently affected by this [AuraEffect].
+     *
+     * @return table targets : a table of [Unit] objects
+     */
     int GetTargetList(Eluna* E, AuraEffect* aurEff)
     {
         std::list<Unit*> list;
@@ -134,36 +222,66 @@ namespace LuaAuraEffects
         return 1;
     }
 
+    /**
+     * Returns the spell ID of the [AuraEffect].
+     *
+     * @return uint32 id
+     */
     int GetId(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetId());
         return 1;
     }
 
+    /**
+     * Returns the effect index of the [AuraEffect].
+     *
+     * @return uint8 effIndex
+     */
     int GetEffIndex(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(uint8(aurEff->GetEffIndex()));
         return 1;
     }
 
+    /**
+     * Returns the aura type of the [AuraEffect].
+     *
+     * @return uint16 auraType
+     */
     int GetAuraType(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(uint16(aurEff->GetAuraType()));
         return 1;
     }
 
+    /**
+     * Returns the [Unit] that cast the [AuraEffect].
+     *
+     * @return [Unit] caster
+     */
     int GetCaster(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetCaster());
         return 1;
     }
 
+    /**
+     * Returns the GUID of the [Unit] that cast the [AuraEffect].
+     *
+     * @return ObjectGuid casterGUID
+     */
     int GetCasterGUID(Eluna* E, AuraEffect* aurEff)
     {
         E->Push(aurEff->GetCasterGUID());
         return 1;
     }
 
+    /**
+     * Returns the [ElunaSpellInfo] of the spell that created this [AuraEffect].
+     *
+     * @return [ElunaSpellInfo] spellInfo
+     */
     int GetSpellInfo(Eluna* E, AuraEffect* aurEff)
     {
         ElunaSpellInfo info(aurEff->GetId());
@@ -173,30 +291,35 @@ namespace LuaAuraEffects
 
     ElunaRegister<AuraEffect> AuraEffectMethods[] =
     {
-        {"GetBase", &LuaAuraEffects::GetBase},
-        {"GetBaseAmount", &LuaAuraEffects::GetBaseAmount},
-        {"GetAmplitude", &LuaAuraEffects::GetAmplitude},
-        {"GetAmount", &LuaAuraEffects::GetAmount},
-        {"SetAmount", &LuaAuraEffects::SetAmount},
-        {"GetPeriodicTimer", &LuaAuraEffects::GetPeriodicTimer},
-        {"SetPeriodicTimer", &LuaAuraEffects::SetPeriodicTimer},
-        {"CalculateAmount", &LuaAuraEffects::CalculateAmount},
-        {"CalculatePeriodic", &LuaAuraEffects::CalculatePeriodic},
-        {"ChangeAmount", &LuaAuraEffects::ChangeAmount},
-        {"RecalculateAmount", &LuaAuraEffects::RecalculateAmount},
-        {"CanBeRecalculated", &LuaAuraEffects::CanBeRecalculated},
-        {"SetCanBeRecalculated", &LuaAuraEffects::SetCanBeRecalculated},
-        {"GetTickNumber", &LuaAuraEffects::GetTickNumber},
-        {"GetRemainingTicks", &LuaAuraEffects::GetRemainingTicks},
-        {"GetTotalTicks", &LuaAuraEffects::GetTotalTicks},
-        {"GetTargetList", &LuaAuraEffects::GetTargetList},
-        {"GetId", &LuaAuraEffects::GetId},
-        {"GetEffIndex", &LuaAuraEffects::GetEffIndex},
-        {"GetAuraType", &LuaAuraEffects::GetAuraType},
-        {"GetCaster", &LuaAuraEffects::GetCaster},
-        {"GetCasterGUID", &LuaAuraEffects::GetCasterGUID},
-        {"GetSpellInfo", &LuaAuraEffects::GetSpellInfo}
+        // Getters
+        { "GetBase",               &LuaAuraEffects::GetBase },
+        { "GetBaseAmount",         &LuaAuraEffects::GetBaseAmount },
+        { "GetAmplitude",          &LuaAuraEffects::GetAmplitude },
+        { "GetAmount",             &LuaAuraEffects::GetAmount },
+        { "GetPeriodicTimer",      &LuaAuraEffects::GetPeriodicTimer },
+        { "GetTickNumber",         &LuaAuraEffects::GetTickNumber },
+        { "GetRemainingTicks",     &LuaAuraEffects::GetRemainingTicks },
+        { "GetTotalTicks",         &LuaAuraEffects::GetTotalTicks },
+        { "GetTargetList",         &LuaAuraEffects::GetTargetList },
+        { "GetId",                 &LuaAuraEffects::GetId },
+        { "GetEffIndex",           &LuaAuraEffects::GetEffIndex },
+        { "GetAuraType",           &LuaAuraEffects::GetAuraType },
+        { "GetCaster",             &LuaAuraEffects::GetCaster },
+        { "GetCasterGUID",         &LuaAuraEffects::GetCasterGUID },
+        { "GetSpellInfo",          &LuaAuraEffects::GetSpellInfo },
+        // Setters
+        { "SetAmount",             &LuaAuraEffects::SetAmount },
+        { "SetPeriodicTimer",      &LuaAuraEffects::SetPeriodicTimer },
+        { "SetCanBeRecalculated",  &LuaAuraEffects::SetCanBeRecalculated },
+        // Booleans
+        { "CanBeRecalculated",     &LuaAuraEffects::CanBeRecalculated },
+        // Other
+        { "CalculateAmount",       &LuaAuraEffects::CalculateAmount },
+        { "CalculatePeriodic",     &LuaAuraEffects::CalculatePeriodic },
+        { "ChangeAmount",          &LuaAuraEffects::ChangeAmount },
+        { "RecalculateAmount",     &LuaAuraEffects::RecalculateAmount },
     };
-};
+}
+
 #endif
 

methods/TrinityCore/AuraMethods.h

@@ -168,6 +168,11 @@ namespace LuaAura
         return 0;
     }
 
+    /**
+     * Returns the [ElunaSpellInfo] of the spell that created this [Aura].
+     *
+     * @return [ElunaSpellInfo] spellInfo
+     */
     int GetSpellInfo(Eluna* E, Aura* aura)
     {
         ElunaSpellInfo info(aura->GetId());