internal FinalBuffs(Buff buff, BuffDistribution buffDistribution, Dictionary <long, long> buffPresence, long phaseDuration)
 {
     if (buff.Type == BuffType.Duration)
     {
         Uptime = Math.Round(100.0 * buffDistribution.GetUptime(buff.ID) / phaseDuration, ParserHelper.BuffDigit);
     }
     else if (buff.Type == BuffType.Intensity)
     {
         Uptime = Math.Round((double)buffDistribution.GetUptime(buff.ID) / phaseDuration, ParserHelper.BuffDigit);
         if (buffPresence.TryGetValue(buff.ID, out long presenceValueBoon))
         {
             Presence = Math.Round(100.0 * presenceValueBoon / phaseDuration, ParserHelper.BuffDigit);
         }
     }
 }
        internal static Dictionary <long, FinalPlayerBuffs>[] GetBuffsForSelf(ParsedEvtcLog log, Player player, long start, long end)
        {
            var buffs       = new Dictionary <long, FinalPlayerBuffs>();
            var activeBuffs = new Dictionary <long, FinalPlayerBuffs>();

            BuffDistribution        selfBuffs    = player.GetBuffDistribution(log, start, end);
            Dictionary <long, long> buffPresence = player.GetBuffPresence(log, start, end);

            long phaseDuration        = end - start;
            long playerActiveDuration = player.GetActiveDuration(log, start, end);

            foreach (Buff boon in player.GetTrackedBuffs(log))
            {
                if (selfBuffs.HasBuffID(boon.ID))
                {
                    var uptime = new FinalPlayerBuffs
                    {
                        Uptime          = 0,
                        Generation      = 0,
                        Overstack       = 0,
                        Wasted          = 0,
                        UnknownExtended = 0,
                        ByExtension     = 0,
                        Extended        = 0
                    };
                    var uptimeActive = new FinalPlayerBuffs
                    {
                        Uptime          = 0,
                        Generation      = 0,
                        Overstack       = 0,
                        Wasted          = 0,
                        UnknownExtended = 0,
                        ByExtension     = 0,
                        Extended        = 0
                    };
                    buffs[boon.ID]       = uptime;
                    activeBuffs[boon.ID] = uptimeActive;
                    double generationValue       = selfBuffs.GetGeneration(boon.ID, player.AgentItem);
                    double uptimeValue           = selfBuffs.GetUptime(boon.ID);
                    double overstackValue        = selfBuffs.GetOverstack(boon.ID, player.AgentItem);
                    double wasteValue            = selfBuffs.GetWaste(boon.ID, player.AgentItem);
                    double unknownExtensionValue = selfBuffs.GetUnknownExtension(boon.ID, player.AgentItem);
                    double extensionValue        = selfBuffs.GetExtension(boon.ID, player.AgentItem);
                    double extendedValue         = selfBuffs.GetExtended(boon.ID, player.AgentItem);
                    if (boon.Type == BuffType.Duration)
                    {
                        uptime.Uptime          = Math.Round(100.0 * uptimeValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.Generation      = Math.Round(100.0 * generationValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.Overstack       = Math.Round(100.0 * (overstackValue + generationValue) / phaseDuration, ParserHelper.BuffDigit);
                        uptime.Wasted          = Math.Round(100.0 * wasteValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.UnknownExtended = Math.Round(100.0 * unknownExtensionValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.ByExtension     = Math.Round(100.0 * extensionValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.Extended        = Math.Round(100.0 * extendedValue / phaseDuration, ParserHelper.BuffDigit);
                        //
                        if (playerActiveDuration > 0)
                        {
                            uptimeActive.Uptime          = Math.Round(100.0 * uptimeValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.Generation      = Math.Round(100.0 * generationValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.Overstack       = Math.Round(100.0 * (overstackValue + generationValue) / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.Wasted          = Math.Round(100.0 * wasteValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.UnknownExtended = Math.Round(100.0 * unknownExtensionValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.ByExtension     = Math.Round(100.0 * extensionValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.Extended        = Math.Round(100.0 * extendedValue / playerActiveDuration, ParserHelper.BuffDigit);
                        }
                    }
                    else if (boon.Type == BuffType.Intensity)
                    {
                        uptime.Uptime          = Math.Round(uptimeValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.Generation      = Math.Round(generationValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.Overstack       = Math.Round((overstackValue + generationValue) / phaseDuration, ParserHelper.BuffDigit);
                        uptime.Wasted          = Math.Round(wasteValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.UnknownExtended = Math.Round(unknownExtensionValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.ByExtension     = Math.Round(extensionValue / phaseDuration, ParserHelper.BuffDigit);
                        uptime.Extended        = Math.Round(extendedValue / phaseDuration, ParserHelper.BuffDigit);
                        //
                        if (playerActiveDuration > 0)
                        {
                            uptimeActive.Uptime          = Math.Round(uptimeValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.Generation      = Math.Round(generationValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.Overstack       = Math.Round((overstackValue + generationValue) / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.Wasted          = Math.Round(wasteValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.UnknownExtended = Math.Round(unknownExtensionValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.ByExtension     = Math.Round(extensionValue / playerActiveDuration, ParserHelper.BuffDigit);
                            uptimeActive.Extended        = Math.Round(extendedValue / playerActiveDuration, ParserHelper.BuffDigit);
                        }
                        //
                        if (buffPresence.TryGetValue(boon.ID, out long presenceValueBoon))
                        {
                            uptime.Presence = Math.Round(100.0 * presenceValueBoon / phaseDuration, ParserHelper.BuffDigit);
                            //
                            if (playerActiveDuration > 0)
                            {
                                uptimeActive.Presence = Math.Round(100.0 * presenceValueBoon / playerActiveDuration, ParserHelper.BuffDigit);
                            }
                        }
                    }
                }
            }
            return(new Dictionary <long, FinalPlayerBuffs>[] { buffs, activeBuffs });
        }
Esempio n. 3
0
        internal static (List <Dictionary <long, FinalPlayerBuffs> >, List <Dictionary <long, FinalPlayerBuffs> >) GetBuffsForSelf(ParsedEvtcLog log, Player player)
        {
            var selfBuffsActive     = new List <Dictionary <long, FinalPlayerBuffs> >();
            var selfBuffs           = new List <Dictionary <long, FinalPlayerBuffs> >();
            List <PhaseData> phases = log.FightData.GetPhases(log);

            for (int phaseIndex = 0; phaseIndex < phases.Count; phaseIndex++)
            {
                var final       = new Dictionary <long, FinalPlayerBuffs>();
                var finalActive = new Dictionary <long, FinalPlayerBuffs>();

                PhaseData phase = phases[phaseIndex];

                BuffDistribution        selfBoons    = player.GetBuffDistribution(log, phaseIndex);
                Dictionary <long, long> buffPresence = player.GetBuffPresence(log, phaseIndex);

                long phaseDuration        = phase.DurationInMS;
                long playerActiveDuration = phase.GetActorActiveDuration(player, log);
                foreach (Buff boon in player.TrackedBuffs)
                {
                    if (selfBoons.ContainsKey(boon.ID))
                    {
                        var uptime = new FinalPlayerBuffs
                        {
                            Uptime          = 0,
                            Generation      = 0,
                            Overstack       = 0,
                            Wasted          = 0,
                            UnknownExtended = 0,
                            ByExtension     = 0,
                            Extended        = 0
                        };
                        var uptimeActive = new FinalPlayerBuffs
                        {
                            Uptime          = 0,
                            Generation      = 0,
                            Overstack       = 0,
                            Wasted          = 0,
                            UnknownExtended = 0,
                            ByExtension     = 0,
                            Extended        = 0
                        };
                        final[boon.ID]       = uptime;
                        finalActive[boon.ID] = uptimeActive;
                        double generationValue       = selfBoons.GetGeneration(boon.ID, player.AgentItem);
                        double uptimeValue           = selfBoons.GetUptime(boon.ID);
                        double overstackValue        = selfBoons.GetOverstack(boon.ID, player.AgentItem);
                        double wasteValue            = selfBoons.GetWaste(boon.ID, player.AgentItem);
                        double unknownExtensionValue = selfBoons.GetUnknownExtension(boon.ID, player.AgentItem);
                        double extensionValue        = selfBoons.GetExtension(boon.ID, player.AgentItem);
                        double extendedValue         = selfBoons.GetExtended(boon.ID, player.AgentItem);
                        if (boon.Type == BuffType.Duration)
                        {
                            uptime.Uptime          = Math.Round(100.0 * uptimeValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.Generation      = Math.Round(100.0 * generationValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.Overstack       = Math.Round(100.0 * (overstackValue + generationValue) / phaseDuration, ParserHelper.BuffDigit);
                            uptime.Wasted          = Math.Round(100.0 * wasteValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.UnknownExtended = Math.Round(100.0 * unknownExtensionValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.ByExtension     = Math.Round(100.0 * extensionValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.Extended        = Math.Round(100.0 * extendedValue / phaseDuration, ParserHelper.BuffDigit);
                            //
                            if (playerActiveDuration > 0)
                            {
                                uptimeActive.Uptime          = Math.Round(100.0 * uptimeValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.Generation      = Math.Round(100.0 * generationValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.Overstack       = Math.Round(100.0 * (overstackValue + generationValue) / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.Wasted          = Math.Round(100.0 * wasteValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.UnknownExtended = Math.Round(100.0 * unknownExtensionValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.ByExtension     = Math.Round(100.0 * extensionValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.Extended        = Math.Round(100.0 * extendedValue / playerActiveDuration, ParserHelper.BuffDigit);
                            }
                        }
                        else if (boon.Type == BuffType.Intensity)
                        {
                            uptime.Uptime          = Math.Round(uptimeValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.Generation      = Math.Round(generationValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.Overstack       = Math.Round((overstackValue + generationValue) / phaseDuration, ParserHelper.BuffDigit);
                            uptime.Wasted          = Math.Round(wasteValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.UnknownExtended = Math.Round(unknownExtensionValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.ByExtension     = Math.Round(extensionValue / phaseDuration, ParserHelper.BuffDigit);
                            uptime.Extended        = Math.Round(extendedValue / phaseDuration, ParserHelper.BuffDigit);
                            //
                            if (playerActiveDuration > 0)
                            {
                                uptimeActive.Uptime          = Math.Round(uptimeValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.Generation      = Math.Round(generationValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.Overstack       = Math.Round((overstackValue + generationValue) / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.Wasted          = Math.Round(wasteValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.UnknownExtended = Math.Round(unknownExtensionValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.ByExtension     = Math.Round(extensionValue / playerActiveDuration, ParserHelper.BuffDigit);
                                uptimeActive.Extended        = Math.Round(extendedValue / playerActiveDuration, ParserHelper.BuffDigit);
                            }
                            //
                            if (buffPresence.TryGetValue(boon.ID, out long presenceValueBoon))
                            {
                                uptime.Presence = Math.Round(100.0 * presenceValueBoon / phaseDuration, ParserHelper.BuffDigit);
                                //
                                if (playerActiveDuration > 0)
                                {
                                    uptimeActive.Presence = Math.Round(100.0 * presenceValueBoon / playerActiveDuration, ParserHelper.BuffDigit);
                                }
                            }
                        }
                    }
                }

                selfBuffs.Add(final);
                selfBuffsActive.Add(finalActive);
            }
            return(selfBuffs, selfBuffsActive);
        }