示例#1
0
 public static int CompareByRP(AbilityDK_Base a, AbilityDK_Base b)
 {
     return(CompareByThreatPerCost(a, b, DKCostTypes.RunicPower));
 }
示例#2
0
 public static int CompareThreatByRunes(AbilityDK_Base a, AbilityDK_Base b)
 {
     return(CompareByThreatPerCost(a, b, DKCostTypes.Death));
 }
示例#3
0
 public static int CompareByTotalThreat(AbilityDK_Base a, AbilityDK_Base b)
 {
     return(CompareByThreatPerCost(a, b, DKCostTypes.NumCostTypes));
 }
示例#4
0
 public static int CompareThreatByCooldown(AbilityDK_Base a, AbilityDK_Base b)
 {
     return(CompareByThreatPerCost(a, b, DKCostTypes.CooldownTime));
 }
示例#5
0
        public static int CompareByThreatPerCost(AbilityDK_Base a, AbilityDK_Base b, DKCostTypes t)
        {
            int   ic     = 0;
            float aRunes = 1;
            float bRunes = 1;

            // Sum of cost:
            switch (t)
            {
            case DKCostTypes.Blood:
                aRunes = a.AbilityCost[(int)DKCostTypes.Blood];
                bRunes = b.AbilityCost[(int)DKCostTypes.Blood];
                break;

            case DKCostTypes.Frost:
                aRunes = a.AbilityCost[(int)DKCostTypes.Frost];
                bRunes = b.AbilityCost[(int)DKCostTypes.Frost];
                break;

            case DKCostTypes.UnHoly:
                aRunes = a.AbilityCost[(int)DKCostTypes.UnHoly];
                bRunes = b.AbilityCost[(int)DKCostTypes.UnHoly];
                break;

            case DKCostTypes.Death:
                aRunes = a.AbilityCost[(int)DKCostTypes.Blood] + a.AbilityCost[(int)DKCostTypes.Frost] + a.AbilityCost[(int)DKCostTypes.UnHoly];
                bRunes = b.AbilityCost[(int)DKCostTypes.Blood] + b.AbilityCost[(int)DKCostTypes.Frost] + b.AbilityCost[(int)DKCostTypes.UnHoly];
                break;

            case DKCostTypes.CastTime:
            case DKCostTypes.CooldownTime:
            case DKCostTypes.DurationTime:
                aRunes = a.AbilityCost[(int)t] / 1000;
                bRunes = b.AbilityCost[(int)t] / 1000;
                break;

            case DKCostTypes.RunicPower:
                aRunes = a.AbilityCost[(int)t];
                bRunes = b.AbilityCost[(int)t];
                break;

            default:
                aRunes = 1;
                bRunes = 1;
                break;
            }
            if (aRunes != 0 || bRunes != 0)
            {
                if (aRunes != 0 && bRunes != 0)
                {
                    float avalue = a.GetTotalThreat() / aRunes;
                    float bvalue = b.GetTotalThreat() / bRunes;
                    if (avalue != bvalue)
                    {
                        // This is setup where we want a descending order.
                        if (avalue > bvalue)
                        {
                            ic = -1;
                        }
                        else
                        {
                            ic = 1;
                        }
                    }
                }
                else // one of them are 0
                {
                    if (aRunes > bRunes)
                    {
                        ic = -1;
                    }
                    else
                    {
                        ic = 1;
                    }
                }
            }
            return(ic);
        }