Vorspire

/*
 * Name:        World of Warcraft Level System Utility (Pre-LK with LK estimations)
 * Version:     1.0.0.0
 * License:     GNU/GPL
 * Support: RunUO x
 * Author:      Vorspire
 * Date:        02-05-09 (2nd May, 2009)
 * Server:      Rhovanion-PK: CORE
 * Website: http://www.rpk-uo.com
 * Research:    Based on algorithms provided at http://www.wowwiki.com/Formulas:XP_To_Level
 * Summary:
 *
 * A simple library of simple utilities using algorithms designed to emulate aspects
 * of the level system used in World of Warcraft.
 *
 * This utility package (SDK) is *NOT* a level system. It was designed to provide a means
 * for developers to develop a WoW-based level system without having to decipher all
 * of the formulae and equations associated with WoW's level system.
 *
 * As of now, this SDK provides accuracy up to level 70, anything above level 70 is
 * found by educated estimation.
 *
 * Everything you need to know about each function has been decribed using documentation
 * nodes for easy-reading and to enhance your understanding by providing correct IDE
 * tooltips when using professional development software(s).
 *
 * Feel free to redistribute/update/edit as you like.
 * Some tweaks may be required for full LK support.
*/

using System;

namespace WoW
{
    /// <summary>
    /// The 'Grey to Skull' Level Color scale as used in World of Warcraft
    /// Key values represent the UO hue relevant to the Key names
    /// 'Skull' is represented by a dark-red
    /// </summary>
    public enum LevelColor
    {
        Grey = 946,
        Green = 243,
        Yellow = 53,
        Orange = 58,
        Red = 34,
        Skull = 144
    }

    /// <summary>
    /// Experience bases for NPCs' of levels that would be found in these zones
    /// Azeroth (1->58->63~),
    /// Outland (57->68->73~),
    /// Northrend (67->83)
    /// </summary>
    public enum ZoneXPBase
    {
        Azeroth = 45,
        Outland = 235,
        Northrend = 580
    }

    public class LevelUtility
    {
        /// <summary>
        /// Factors provided for experience gain calculation
        /// EliteXPFactor default: 2 (effectively doubles base XP)
        /// RestedXPFactor default: 2 (effectively doubles base XP)
        /// </summary>
        public const double
            EliteXPFactor = 2,
            RestedXPFactor = 2;

        /// <summary>
        /// Computes the amount of Experience required to reach the next level
        /// </summary>
        /// <param name="playerLevel">(int) The current level of the player</param>
        /// <param name="xpZone">(ZoneXPBase) The zone XP base to use during calculation</param>
        /// <returns>(int) The total amount of experience required to reach the next level</returns>
        public static int ComputeExperienceReq(int playerLevel, ZoneXPBase xpZone)
        {
            return (int)Round((double)(((8 * playerLevel) + XPDiffReduction(playerLevel)) * XPFromNPC(playerLevel, playerLevel, xpZone) * XPReductionFactor(playerLevel)), -2);
        }

        /// <summary>
        /// Recursively computes the total amount of experience required to reach endLevel from startLevel
        /// endLevel can not be less than, or equal to startLevel, if this occurs, endLevel will be corrected to equal startLevel + 1
        /// </summary>
        /// <param name="startLevel">(int) The level from which to compute from</param>
        /// <param name="endLevel">(int) The level from which to compute to</param>
        /// <param name="xpZone">(ZoneXPBase) The zone XP base to use during calculation</param>
        /// <returns>(int) The total amount of experience required to reach endLevel from startLevel</returns>
        public static int ComputeExperienceReq(int startLevel, int endLevel, ZoneXPBase xpZone)
        {
            int xpReq = 0;

            if (startLevel < 1)
                startLevel = 1;

            if (endLevel <= startLevel)
                endLevel = startLevel + 1;

            for (int i = startLevel; i < endLevel; i++)
            {
                xpReq += ComputeExperienceReq(i, xpZone);
            }

            return xpReq;
        }

        /// <summary>
        /// Computes the experience gain potential
        /// Example: Killing an NPC
        /// </summary>
        /// <param name="playerLevel">(int) The current level of the player that is gaining the experience</param>
        /// <param name="npcLevel">(int) The current level of the NPC that is providing the experience</param>
        /// <param name="rested">(bool) If the player is 'rested', the experience will be factored according to (double)WowLevelUtility.RestedXPFactor</param>
        /// <param name="elite">(bool) If the NPC is 'elite', the experience will be factored according to (double)WoWLevelUtility.EliteXPFactor</param>
        /// <param name="xpZone">(ZoneXPBase) The zone XP base to use during calculation</param>
        /// <returns>(double) The total amount of experience that can potentially be gained from an NPC accroding to player & NPC level matching.</returns>
        public static double ComputeExperienceGain(int playerLevel, int npcLevel, bool rested, bool elite, ZoneXPBase xpZone)
        {
            double baseXP = XPFromNPC(playerLevel, npcLevel, xpZone);

            if (elite)
                baseXP *= EliteXPFactor;

            if (rested)
                baseXP *= RestedXPFactor;

            return baseXP;
        }

        /// <summary>
        /// Gets the level 'color' associated with World of Warcrafts' "Grey to Skull" scale.
        /// Obligatory He-man citation needed.
        /// </summary>
        /// <param name="playerLevel">(int) The current level of the player 'targeting' the NPC.</param>
        /// <param name="npcLevel">(int) The current level of the NPC that is being 'targeted' by the player.</param>
        /// <returns>(WowLevelColor) The level 'color' associated with World of Warcrafts' 'Grey to Skull' scale.
        /// Incidentally, the value name returned also translates into the correct hue id number for use with text.</returns>
        public static LevelColor GetLevelColor(int playerLevel, int npcLevel)
        {
            if (playerLevel + 5 <= npcLevel)
            {
                if (playerLevel + 10 <= npcLevel)
                {
                    return LevelColor.Skull;
                }
                else
                {
                    return LevelColor.Red;
                }
            }
            else
            {
                switch (npcLevel - playerLevel)
                {
                    case 4: { return LevelColor.Orange; }
                    case 3: { return LevelColor.Orange; }
                    case 2: { return LevelColor.Yellow; }
                    case 1: { return LevelColor.Yellow; }
                    case 0: { return LevelColor.Yellow; }
                    case -1: { return LevelColor.Yellow; }
                    case -2: { return LevelColor.Yellow; }
                    default:
                        if (playerLevel <= 5)
                        {
                            return LevelColor.Green;
                        }
                        else
                        {
                            if (playerLevel <= 39)
                            {
                                if (npcLevel <= (playerLevel - 5 - Math.Floor((double)(playerLevel / 10))))
                                {
                                    return LevelColor.Grey;
                                }
                                else
                                {
                                    return LevelColor.Green;
                                }
                            }
                            else
                            {
                                if (npcLevel <= (playerLevel - 1 - Math.Floor((double)(playerLevel / 5))))
                                {
                                    return LevelColor.Grey;
                                }
                                else
                                {
                                    return LevelColor.Green;
                                }
                            }
                        }
                }
            }
        }

        /// <summary>
        /// Computes the amount of experience that an NPC may supply
        /// </summary>
        /// <param name="playerLevel">(int) The current level of the player</param>
        /// <param name="npcLevel">(int) The current level of the NPC</param>
        /// <param name="xpZone">(ZoneXPBase) The zone XP base to use during calculation</param>
        /// <returns>(double) The amount of experience that an NPC may supply</returns>
        public static double XPFromNPC(int playerLevel, int npcLevel, ZoneXPBase xpZone)
        {
            double baseXP = 0.0;

            if (GetLevelColor(playerLevel, npcLevel) == LevelColor.Grey)
                return baseXP;

            baseXP = (int)xpZone + (5 * playerLevel);

            if (npcLevel < playerLevel && npcLevel > ZeroXPLevel(playerLevel))
            {
                return baseXP * (1 - (playerLevel - npcLevel) / XPZeroDiff(playerLevel));
            }
            else if (npcLevel > playerLevel)
            {
                return baseXP * (1 + 0.05 * (npcLevel - playerLevel));
            }

            return baseXP;
        }

        /// <summary>
        /// Calculates the level difference threshold for gaining zero XP
        /// </summary>
        /// <param name="playerLevel">(int) The current level of the player</param>
        /// <returns>(int) The level difference threshold for gaining zero XP</returns>
        public static int XPZeroDiff(int playerLevel)
        {
            if (playerLevel <= 7)
            {
                return 5;
            }
            else if (playerLevel >= 8 && playerLevel <= 9)
            {
                return 6;
            }
            else if (playerLevel >= 10 && playerLevel <= 11)
            {
                return 7;
            }
            else if (playerLevel >= 12 && playerLevel <= 15)
            {
                return 8;
            }
            else if (playerLevel >= 16 && playerLevel <= 19)
            {
                return 9;
            }
            else if (playerLevel >= 20 && playerLevel <= 29)
            {
                return 11;
            }
            else if (playerLevel >= 30 && playerLevel <= 39)
            {
                return 12;
            }
            else if (playerLevel >= 40 && playerLevel <= 44)
            {
                return 13;
            }
            else if (playerLevel >= 45 && playerLevel <= 49)
            {
                return 14;
            }
            else if (playerLevel >= 50 && playerLevel <= 54)
            {
                return 15;
            }
            else if (playerLevel >= 55 && playerLevel <= 59)
            {
                return 16;
            }
            else if (playerLevel >= 60 && playerLevel <= 79)
            {
                return 17;
            }
            else if (playerLevel >= 80)
            {
                return 18;
            }

            return 0;
        }

        /// <summary>
        /// Calculates the 'Grey Level'
        /// The 'Grey Level' is the highest level at which an NPC may not grant experience
        /// </summary>
        /// <param name="playerLevel">(int) The current level of the player</param>
        /// <returns>(int) The highest level at which experience will not be granted</returns>
        public static int ZeroXPLevel(int playerLevel)
        {
            if (playerLevel <= 5)
            {
                return 0;
            }
            else if (playerLevel >= 6 && playerLevel <= 39)
            {
                return (int)(playerLevel - Math.Floor((double)(playerLevel / 10)) - 5);
            }
            else if (playerLevel >= 40 && playerLevel <= 59)
            {
                return (int)(playerLevel - Math.Floor((double)(playerLevel / 5)) - 1);
            }
            else if (playerLevel >= 60)
            {
                return (int)(playerLevel - 9);
            }

            return 0;
        }

        /// <summary>
        /// Calculates the factor of XP reduction to implement difficulty scaling
        /// Effective from level 28 to 59
        /// </summary>
        /// <param name="playerLevel">(int) The current level of the player</param>
        /// <returns>(double) The factor of XP reduction to implement difficulty scaling (Effective for level 28 to 59 only)</returns>
        public static double XPDiffReduction(int playerLevel)
        {
            if (playerLevel <= 28)
            {
                return 0;
            }
            else if (playerLevel == 29)
            {
                return 1;
            }
            else if (playerLevel == 30)
            {
                return 3;
            }
            else if (playerLevel == 31)
            {
                return 6;
            }
            else if (playerLevel >= 32 && playerLevel <= 59)
            {
                return 5 * (playerLevel - 30);
            }

            return 0;
        }

        /// <summary>
        /// Calculates the factor of XP reduction to implement advanced difficulty scaling
        /// Effective for all levels
        /// </summary>
        /// <param name="playerLevel">(int) The current level of the player</param>
        /// <returns>(double) The factor of XP reduction to implement advanced difficulty scaling (Effective for all levels)</returns>
        public static double XPReductionFactor(int playerLevel)
        {
            if (playerLevel <= 10)
            {
                return 1;
            }
            else if (playerLevel >= 11 && playerLevel <= 27)
            {
                return (1 - (playerLevel - 10) / 100);
            }
            else if (playerLevel >= 28 && playerLevel <= 59)
            {
                return 0.82;
            }
            else if (playerLevel >= 60)
            {
                return 1;
            }

            return 1;
        }

        /// <summary>
        /// Provides a means to round (double) values to X amount of digits
        /// All experience requirements are scaled to the nearest 100
        /// Example: Round( 1584.82, -2 ); would return (double) 1600.00
        /// </summary>
        /// <param name="value">(double) The value to round</param>
        /// <param name="digits">(int) Digits must be between -15 and 15</param>
        /// <returns>(double) The rounded value</returns>
        public static double Round(double value, int digits)
        {
            if ((digits < -15) || (digits > 15))
                return value;

            if (digits >= 0)
                return Math.Round(value, digits);

            double n = Math.Pow(10, -digits);

            return Math.Round(value / n, 0) * n;
        }
    }
}