Initial commit

src/server/game/Miscellaneous/Formulas.cpp

@@ -0,0 +1,133 @@
+/*
+ * This file is part of the AzerothCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Formulas.h"
+#include "AreaDefines.h"
+#include "Battleground.h"
+#include "Creature.h"
+#include "Log.h"
+#include "Player.h"
+#include "World.h"
+
+uint32 Acore::XP::BaseGain(uint8 pl_level, uint8 mob_level, ContentLevels content)
+{
+    uint32 baseGain;
+    uint32 nBaseExp;
+
+    switch (content)
+    {
+    case CONTENT_1_60:
+        nBaseExp = 45;
+        break;
+    case CONTENT_61_70:
+        nBaseExp = 235;
+        break;
+    case CONTENT_71_80:
+        nBaseExp = 580;
+        break;
+    default:
+        LOG_ERROR("misc", "BaseGain: Unsupported content level {}", content);
+        nBaseExp = 45;
+        break;
+    }
+
+    if (mob_level >= pl_level)
+    {
+        uint8 nLevelDiff = mob_level - pl_level;
+        if (nLevelDiff > 4)
+            nLevelDiff = 4;
+
+        baseGain = ((pl_level * 5 + nBaseExp) * (20 + nLevelDiff) / 10 + 1) / 2;
+    }
+    else
+    {
+        uint8 gray_level = GetGrayLevel(pl_level);
+        if (mob_level > gray_level)
+        {
+            uint8 ZD = GetZeroDifference(pl_level);
+            baseGain = (pl_level * 5 + nBaseExp) * (ZD + mob_level - pl_level) / ZD;
+        }
+        else
+            baseGain = 0;
+    }
+
+    //sScriptMgr->OnBaseGainCalculation(baseGain, pl_level, mob_level, content); // pussywizard: optimization
+    return baseGain;
+}
+
+uint32 Acore::XP::Gain(Player* player, Unit* unit, bool isBattleGround /*= false*/)
+{
+    Creature* creature = unit->ToCreature();
+    uint32 gain = 0;
+
+    if (!creature || (!creature->IsTotem() && !creature->IsPet() && !creature->IsCritter() &&
+        !creature->HasFlagsExtra(CREATURE_FLAG_EXTRA_NO_XP)))
+    {
+        float xpMod = 1.0f;
+
+        gain = BaseGain(player->GetLevel(), unit->GetLevel(), GetContentLevelsForMapAndZone(unit->GetMapId(), unit->GetZoneId()));
+
+        if (gain && creature)
+        {
+            if (creature->isElite())
+                xpMod *= 2.0f;
+
+            // Instanced mobs (particularly bosses) oftentimes have higher bonuses, especially in later content levels
+            xpMod *= creature->GetCreatureTemplate()->ModExperience;
+        }
+
+        if (isBattleGround)
+        {
+            switch (player->GetMapId())
+            {
+                case MAP_ALTERAC_VALLEY:
+                    xpMod *= sWorld->getRate(RATE_XP_BG_KILL_AV);
+                    break;
+                case MAP_WARSONG_GULCH:
+                    xpMod *= sWorld->getRate(RATE_XP_BG_KILL_WSG);
+                    break;
+                case MAP_ARATHI_BASIN:
+                    xpMod *= sWorld->getRate(RATE_XP_BG_KILL_AB);
+                    break;
+                case MAP_EYE_OF_THE_STORM:
+                    xpMod *= sWorld->getRate(RATE_XP_BG_KILL_EOTS);
+                    break;
+                case MAP_STRAND_OF_THE_ANCIENTS:
+                    xpMod *= sWorld->getRate(RATE_XP_BG_KILL_SOTA);
+                    break;
+                case MAP_ISLE_OF_CONQUEST:
+                    xpMod *= sWorld->getRate(RATE_XP_BG_KILL_IC);
+                    break;
+            }
+        }
+        else
+        {
+            xpMod *= sWorld->getRate(RATE_XP_KILL);
+        }
+
+        // if players dealt less than 50% of the damage and were credited anyway (due to CREATURE_FLAG_EXTRA_NO_PLAYER_DAMAGE_REQ), scale XP gained appropriately (linear scaling)
+        if (creature && creature->GetPlayerDamageReq())
+        {
+            xpMod *= 1.0f - 2.0f * creature->GetPlayerDamageReq() / creature->GetMaxHealth();
+        }
+
+        gain = uint32(gain * xpMod);
+    }
+
+    //sScriptMgr->OnGainCalculation(gain, player, u); // pussywizard: optimization
+    return gain;
+}

src/server/game/Miscellaneous/Formulas.h

@@ -0,0 +1,154 @@
+/*
+ * This file is part of the AzerothCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef ACORE_FORMULAS_H
+#define ACORE_FORMULAS_H
+
+#include "SharedDefines.h"
+#include <cmath>
+
+class Player;
+class Unit;
+
+enum ContentLevels : uint8;
+
+namespace Acore::Honor
+{
+    inline float hk_honor_at_level_f(uint8 level, float multiplier = 1.0f)
+    {
+        float honor = multiplier * level * 1.55f;
+        //sScriptMgr->OnHonorCalculation(honor, level, multiplier); // pussywizard: optimization
+        return honor;
+    }
+
+    inline uint32 hk_honor_at_level(uint8 level, float multiplier = 1.0f)
+    {
+        return uint32(std::ceil(hk_honor_at_level_f(level, multiplier)));
+    }
+}
+
+namespace Acore::XP
+{
+    inline uint8 GetGrayLevel(uint8 pl_level)
+    {
+        uint8 level;
+
+        if (pl_level <= 5)
+            level = 0;
+        else if (pl_level <= 39)
+            level = pl_level - 5 - pl_level / 10;
+        else if (pl_level <= 59)
+            level = pl_level - 1 - pl_level / 5;
+        else
+            level = pl_level - 9;
+
+        //sScriptMgr->OnGrayLevelCalculation(level, pl_level); // pussywizard: optimization
+        return level;
+    }
+
+    inline XPColorChar GetColorCode(uint8 pl_level, uint8 mob_level)
+    {
+        XPColorChar color;
+
+        if (mob_level >= pl_level + 5)
+            color = XP_RED;
+        else if (mob_level >= pl_level + 3)
+            color = XP_ORANGE;
+        else if (mob_level >= pl_level - 2)
+            color = XP_YELLOW;
+        else if (mob_level > GetGrayLevel(pl_level))
+            color = XP_GREEN;
+        else
+            color = XP_GRAY;
+
+        //sScriptMgr->OnColorCodeCalculation(color, pl_level, mob_level); // pussywizard: optimization
+        return color;
+    }
+
+    inline uint8 GetZeroDifference(uint8 pl_level)
+    {
+        uint8 diff;
+
+        if (pl_level < 8)
+            diff = 5;
+        else if (pl_level < 10)
+            diff = 6;
+        else if (pl_level < 12)
+            diff = 7;
+        else if (pl_level < 16)
+            diff = 8;
+        else if (pl_level < 20)
+            diff = 9;
+        else if (pl_level < 30)
+            diff = 11;
+        else if (pl_level < 40)
+            diff = 12;
+        else if (pl_level < 45)
+            diff = 13;
+        else if (pl_level < 50)
+            diff = 14;
+        else if (pl_level < 55)
+            diff = 15;
+        else if (pl_level < 60)
+            diff = 16;
+        else
+            diff = 17;
+
+        //sScriptMgr->OnZeroDifferenceCalculation(diff, pl_level); // pussywizard: optimization
+        return diff;
+    }
+
+    uint32 BaseGain(uint8 pl_level, uint8 mob_level, ContentLevels content);
+
+    uint32 Gain(Player* player, Unit* unit, bool isBattleGround = false);
+
+    inline float xp_in_group_rate(uint32 count, bool isRaid)
+    {
+        float rate;
+
+        if (isRaid)
+        {
+            // FIXME: Must apply decrease modifiers depending on raid size.
+            rate = 1.0f;
+        }
+        else
+        {
+            switch (count)
+            {
+            case 0:
+            case 1:
+            case 2:
+                rate = 1.0f;
+                break;
+            case 3:
+                rate = 1.166f;
+                break;
+            case 4:
+                rate = 1.3f;
+                break;
+            case 5:
+            default:
+                rate = 1.4f;
+            }
+        }
+
+        //sScriptMgr->OnGroupRateCalculation(rate, count, isRaid); // pussywizard: optimization
+        return rate;
+    }
+}
+
+#endif