예제 #1
0
파일: ShadowUser.cs 프로젝트: say1981/Rawr
        public override void Calculate(CharacterCalculationsWarlock calculations)
        {
            float chanceToHit = CalculationsWarlock.ChanceToHit(calculations.CalculationOptions.TargetLevel, HitPercent);

            DirectShadowHitsPerSecond = (1 / MbFrequency + 1f / 12f) * chanceToHit;
            EffectiveCritRate         = 0;
        }
예제 #2
0
파일: RaidISB.cs 프로젝트: say1981/Rawr
        public float CalculateISBUptime(CharacterCalculationsWarlock calculations)
        {
            float chanceToHit = CalculationsWarlock.ChanceToHit(calculations.CalculationOptions.TargetLevel, calculations.HitPercent);
            float myDirectShadowHitsPerSecond = calculations.SpellRotation.ShadowBoltCastRatio / calculations.SpellRotation.ShadowBoltCastTime * chanceToHit;
            float myEffectiveCritRate         = myDirectShadowHitsPerSecond * calculations.CritPercent;

            float raidDirectShadowHitsPerSecond = 0, raidEffectiveCritRate = 0, raidShadowDps = 0;
            //for (int i = 0; i <= lastEnabledWarlock; i++)
            //{
            //    WarlockControl currentWarlock = (WarlockControl)this.groupBoxWarlocks.Controls["suWarlock" + (i + 1)];
            //    currentWarlock.Calculate(calculations);
            //    raidDirectShadowHitsPerSecond += currentWarlock.DirectShadowHitsPerSecond;
            //    raidEffectiveCritRate += currentWarlock.EffectiveCritRate;
            //    raidShadowDps += currentWarlock.ShadowDps;
            //}
            //for (int i = 0; i <= lastEnabledShadowPriest; i++)
            //{
            //    ShadowPriestControl currentSp = (ShadowPriestControl)this.groupBoxShadowPriests.Controls["suShadowPriest" + (i + 1)];
            //    currentSp.Calculate(calculations);
            //    raidDirectShadowHitsPerSecond += currentSp.DirectShadowHitsPerSecond;
            //    raidShadowDps += currentSp.ShadowDps;
            //}

            float raidIsbUptime = 1 - (float)Math.Pow(raidEffectiveCritRate, 4);
            float totalIsbUptime = 1 - (float)Math.Pow(raidEffectiveCritRate + myEffectiveCritRate, 4);

            calculations.RaidDpsFromIsb = raidShadowDps * 1.2f * (totalIsbUptime - raidIsbUptime);

            return(totalIsbUptime);
        }
예제 #3
0
파일: ShadowUser.cs 프로젝트: say1981/Rawr
 public override void Calculate(CharacterCalculationsWarlock calculations)
 {
     if (HitPercent != 0 && CritPercent != 0 && SbCastTime != 0 && SbCastRatio != 0)
     {
         float chanceToHit = CalculationsWarlock.ChanceToHit(calculations.CalculationOptions.TargetLevel, HitPercent);
         DirectShadowHitsPerSecond = SbCastRatio / SbCastTime * chanceToHit;
         EffectiveCritRate         = CritPercent * DirectShadowHitsPerSecond;
     }
 }
예제 #4
0
파일: Spell.cs 프로젝트: say1981/Rawr
        //public float HealthPerSecond { get; set; }

        public void CalculateDerivedStats(CharacterCalculationsWarlock calculations)
        {
            //hit rate
            ChanceToHit = CalculationsWarlock.ChanceToHit(calculations.CalculationOptions.TargetLevel, calculations.HitPercent);
            if (SpellTree == SpellTree.Affliction)
            {
                ChanceToHit = Math.Min(0.99f, ChanceToHit + 2 * calculations.CalculationOptions.Suppression);
            }

            //cast time
            CastTime = BaseCastTime / (1 + 0.01f * calculations.HastePercent);
            if (calculations.BasicStats.Bloodlust > 0)
            {
                CastTime /= (1 + 0.3f * 40 / 600);
            }
            CastTime += calculations.CalculationOptions.Latency;
            if (CastTime < calculations.GlobalCooldown + calculations.CalculationOptions.Latency)
            {
                CastTime = calculations.GlobalCooldown + calculations.CalculationOptions.Latency;
            }
            //for DoTs, factor in the chance to miss (because you have to re-apply)
            if (BaseDotDuration != 0)
            {
                CastTime /= ChanceToHit;
            }
            if (CastTime < calculations.GlobalCooldown + calculations.CalculationOptions.Latency)
            {
                CastTime = calculations.GlobalCooldown + calculations.CalculationOptions.Latency;
            }

            //frequency
            if (BaseDotDuration == 0)
            {
                Frequency = CastTime;
            }
            else
            {
                Frequency = BaseDotDuration + CastTime + calculations.CalculationOptions.DotGap - (BaseCastTime + calculations.CalculationOptions.Latency);
            }

            //mana cost
            ManaCost = BaseManaCost;
            if (SpellTree == SpellTree.Destruction)
            {
                ManaCost *= (1 - 0.01f * calculations.CalculationOptions.Cataclysm);
            }
            if (BaseDotDuration != 0)
            {
                ManaCost /= ChanceToHit;
            }
            ManaCost      = (float)Math.Round(ManaCost);
            ManaPerSecond = ManaCost / Frequency;

            //cast ratio
            CastRatio = CastTime / Frequency;
        }
예제 #5
0
파일: ShadowUser.cs 프로젝트: say1981/Rawr
        public static void CalculateRaidIsbUptime(CharacterCalculationsWarlock calculations)
        {
            if (calculations.CalculationOptions.IsbMethod == IsbMethod.Raid)
            {
                float chanceToHit = CalculationsWarlock.ChanceToHit(calculations.CalculationOptions.TargetLevel, calculations.HitPercent);
                float myDirectShadowHitsPerSecond = calculations.SpellRotation.ShadowBoltCastRatio / calculations.SpellRotation.ShadowBoltCastTime * chanceToHit;
                float myEffectiveCritRate         = myDirectShadowHitsPerSecond * calculations.CritPercent;

                float raidDirectShadowHitsPerSecond = 0, raidEffectiveCritRate = 0, raidShadowDps = 0;
                for (int i = 0; i < calculations.CalculationOptions.NumRaidWarlocks; i++)
                {
                    SUWarlock currentWarlock = calculations.CalculationOptions.RaidWarlocks[i];
                    currentWarlock.Calculate(calculations);
                    raidDirectShadowHitsPerSecond += currentWarlock.DirectShadowHitsPerSecond;
                    raidEffectiveCritRate         += currentWarlock.EffectiveCritRate;
                    raidShadowDps += currentWarlock.ShadowDps;
                }
                for (int i = 0; i < calculations.CalculationOptions.NumRaidShadowPriests; i++)
                {
                    SUShadowPriest currentSp = calculations.CalculationOptions.RaidShadowPriests[i];
                    currentSp.Calculate(calculations);
                    raidDirectShadowHitsPerSecond += currentSp.DirectShadowHitsPerSecond;
                    raidShadowDps += currentSp.ShadowDps;
                }

                myEffectiveCritRate   /= 100;
                raidEffectiveCritRate /= 100;
                float raidIsbUptime = 1 - (float)Math.Pow(1 - (raidEffectiveCritRate / raidDirectShadowHitsPerSecond), 4);
                float totalIsbUptime = 1 - (float)Math.Pow(1 - ((raidEffectiveCritRate + myEffectiveCritRate) / (raidDirectShadowHitsPerSecond + myDirectShadowHitsPerSecond)), 4);

                calculations.RaidDpsFromIsb = raidShadowDps * 0.2f * (totalIsbUptime - raidIsbUptime);
                calculations.IsbUptime      = totalIsbUptime;
            }
            else
            {
                calculations.RaidDpsFromIsb = 0;
                calculations.IsbUptime      = calculations.CalculationOptions.CustomIsbUptime;
            }
        }