[RUO X] World of Warcraft Level System Utility/SDK Implimentation Guide
Pastebin - View this script with highlighting.
Code:
/*
* 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.
*/
Code:
using System;
using Server;
using Server.Items;
using Server.Mobiles;
using Server.Network;
namespace Server.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;
}
}
}