Example #1
0
        private void CreateDefTable(int phaseIndex)
        {
            //generate defstats table
            WriteLine(new[] { "Sub Group", "Profession", "Name",
                              "DMG Taken", "DMG Barrier", "Blocked", "Invulned", "Evaded", "Dodges" });
            int count = 0;

            foreach (Player player in _log.PlayerList)
            {
                if (player.IsFakeActor)
                {
                    continue;
                }
                FinalDefenses defenses = player.GetDefenses(_log, phaseIndex);

                WriteLine(new[] { player.Group.ToString(), player.Prof, player.Character,
                                  defenses.DamageTaken.ToString(), defenses.DamageBarrier.ToString(), defenses.BlockedCount.ToString(), defenses.InvulnedCount.ToString(), defenses.EvadedCount.ToString(), defenses.DodgeCount.ToString() });
                count++;
            }
            while (count < 15)//so each graph has equal spacing
            {
                NewLine();
                count++;
            }
        }
        private void CalculateDefenses()
        {
            CombatData combatData = _log.CombatData;

            foreach (Player player in _log.PlayerList)
            {
                FinalDefenses[] phaseDefense = new FinalDefenses[_statistics.Phases.Count];
                for (int phaseIndex = 0; phaseIndex < _statistics.Phases.Count; phaseIndex++)
                {
                    FinalDefenses final = new FinalDefenses();

                    PhaseData phase = _statistics.Phases[phaseIndex];
                    long      start = _log.FightData.ToLogSpace(phase.Start);
                    long      end   = _log.FightData.ToLogSpace(phase.End);

                    List <DamageLog> damageLogs = player.GetDamageTakenLogs(null, _log, phase.Start, phase.End);
                    //List<DamageLog> healingLogs = player.getHealingReceivedLogs(log, phase.getStart(), phase.getEnd());

                    final.DamageTaken = damageLogs.Sum(x => (long)x.Damage);
                    //final.allHealReceived = healingLogs.Sum(x => x.getDamage());
                    final.BlockedCount     = damageLogs.Count(x => x.Result == ParseEnum.Result.Block);
                    final.InvulnedCount    = 0;
                    final.DamageInvulned   = 0;
                    final.EvadedCount      = damageLogs.Count(x => x.Result == ParseEnum.Result.Evade);
                    final.DodgeCount       = player.GetCastLogs(_log, 0, _log.FightData.FightDuration).Count(x => x.SkillId == SkillItem.DodgeId);
                    final.DamageBarrier    = damageLogs.Sum(x => x.ShieldDamage);
                    final.InterruptedCount = damageLogs.Count(x => x.Result == ParseEnum.Result.Interrupt);
                    foreach (DamageLog log in damageLogs.Where(x => x.Result == ParseEnum.Result.Absorb))
                    {
                        final.InvulnedCount++;
                        final.DamageInvulned += log.Damage;
                    }
                    List <CombatItem> deads = combatData.GetStatesData(player.InstID, ParseEnum.StateChange.ChangeDead, start, end);
                    List <CombatItem> downs = combatData.GetStatesData(player.InstID, ParseEnum.StateChange.ChangeDown, start, end);
                    List <CombatItem> dcs   = combatData.GetStatesData(player.InstID, ParseEnum.StateChange.Despawn, start, end);
                    final.DownCount = downs.Count - combatData.GetBoonData(5620).Where(x => x.SrcInstid == player.InstID && x.Time >= start && x.Time <= end && x.IsBuffRemove == ParseEnum.BuffRemove.All).Count();
                    final.DeadCount = deads.Count;
                    final.DcCount   = dcs.Count;

                    phaseDefense[phaseIndex] = final;
                }
                List <(long start, long end)> dead = new List <(long start, long end)>();
                List <(long start, long end)> down = new List <(long start, long end)>();
                List <(long start, long end)> dc   = new List <(long start, long end)>();
                combatData.GetAgentStatus(player.FirstAware, player.LastAware, player.InstID, dead, down, dc);

                for (int phaseIndex = 0; phaseIndex < _statistics.Phases.Count; phaseIndex++)
                {
                    FinalDefenses defenses = phaseDefense[phaseIndex];
                    PhaseData     phase    = _statistics.Phases[phaseIndex];
                    long          start    = phase.Start;
                    long          end      = phase.End;
                    defenses.DownDuration = (int)down.Where(x => x.end >= start && x.start <= end).Sum(x => Math.Min(end, x.end) - Math.Max(x.start, start));
                    defenses.DeadDuration = (int)dead.Where(x => x.end >= start && x.start <= end).Sum(x => Math.Min(end, x.end) - Math.Max(x.start, start));
                    defenses.DcDuration   = (int)dc.Where(x => x.end >= start && x.start <= end).Sum(x => Math.Min(end, x.end) - Math.Max(x.start, start));
                }

                _statistics.Defenses[player] = phaseDefense;
            }
        }
        private void CalculateDefenses()
        {
            foreach (Player player in _log.PlayerList)
            {
                FinalDefenses[] phaseDefense = new FinalDefenses[_statistics.Phases.Count];
                for (int phaseIndex = 0; phaseIndex < _statistics.Phases.Count; phaseIndex++)
                {
                    FinalDefenses final = new FinalDefenses();

                    PhaseData phase = _statistics.Phases[phaseIndex];

                    List <DamageLog> damageLogs = player.GetDamageTakenLogs(_log, phase.Start, phase.End);
                    //List<DamageLog> healingLogs = player.getHealingReceivedLogs(log, phase.getStart(), phase.getEnd());

                    final.DamageTaken = damageLogs.Sum(x => (long)x.Damage);
                    //final.allHealReceived = healingLogs.Sum(x => x.getDamage());
                    final.BlockedCount   = damageLogs.Count(x => x.Result == ParseEnum.Result.Block);
                    final.InvulnedCount  = 0;
                    final.DamageInvulned = 0;
                    final.EvadedCount    = damageLogs.Count(x => x.Result == ParseEnum.Result.Evade);
                    final.DamageBarrier  = damageLogs.Sum(x => x.IsShields == 1 ? x.Damage : 0);
                    foreach (DamageLog log in damageLogs.Where(x => x.Result == ParseEnum.Result.Absorb))
                    {
                        final.InvulnedCount++;
                        final.DamageInvulned += log.Damage;
                    }

                    phaseDefense[phaseIndex] = final;
                }
                _statistics.Defenses[player] = phaseDefense;
            }
        }
        private void SetDefenses(ParsedLog log)
        {
            List <(long start, long end)> dead = new List <(long start, long end)>();
            List <(long start, long end)> down = new List <(long start, long end)>();
            List <(long start, long end)> dc   = new List <(long start, long end)>();

            log.CombatData.GetAgentStatus(FirstAware, LastAware, InstID, dead, down, dc, log.FightData.FightStart, log.FightData.FightEnd);
            _defenses = new List <FinalDefenses>();
            foreach (PhaseData phase in log.FightData.GetPhases(log))
            {
                FinalDefenses final = new FinalDefenses();
                _defenses.Add(final);
                long             start      = log.FightData.ToLogSpace(phase.Start);
                long             end        = log.FightData.ToLogSpace(phase.End);
                List <DamageLog> damageLogs = GetDamageTakenLogs(null, log, phase.Start, phase.End);
                //List<DamageLog> healingLogs = player.getHealingReceivedLogs(log, phase.getStart(), phase.getEnd());

                final.DamageTaken = damageLogs.Sum(x => (long)x.Damage);
                //final.allHealReceived = healingLogs.Sum(x => x.getDamage());
                final.BlockedCount     = damageLogs.Count(x => x.Result == ParseEnum.Result.Block);
                final.InvulnedCount    = 0;
                final.DamageInvulned   = 0;
                final.EvadedCount      = damageLogs.Count(x => x.Result == ParseEnum.Result.Evade);
                final.DodgeCount       = GetCastLogs(log, 0, log.FightData.FightDuration).Count(x => x.SkillId == SkillItem.DodgeId);
                final.DamageBarrier    = damageLogs.Sum(x => x.ShieldDamage);
                final.InterruptedCount = damageLogs.Count(x => x.Result == ParseEnum.Result.Interrupt);
                foreach (DamageLog dl in damageLogs.Where(x => x.Result == ParseEnum.Result.Absorb))
                {
                    final.InvulnedCount++;
                    final.DamageInvulned += dl.Damage;
                }
                List <CombatItem> deads = log.CombatData.GetStatesData(InstID, ParseEnum.StateChange.ChangeDead, start, end);
                List <CombatItem> downs = log.CombatData.GetStatesData(InstID, ParseEnum.StateChange.ChangeDown, start, end);
                List <CombatItem> dcs   = log.CombatData.GetStatesData(InstID, ParseEnum.StateChange.Despawn, start, end);
                final.DownCount = downs.Count - log.CombatData.GetBoonData(5620).Where(x => x.SrcInstid == InstID && x.Time >= start && x.Time <= end && x.IsBuffRemove == ParseEnum.BuffRemove.All).Count();
                final.DeadCount = deads.Count;
                final.DcCount   = dcs.Count;

                //
                start = phase.Start;
                end   = phase.End;
                final.DownDuration = (int)down.Where(x => x.end >= start && x.start <= end).Sum(x => Math.Min(end, x.end) - Math.Max(x.start, start));
                final.DeadDuration = (int)dead.Where(x => x.end >= start && x.start <= end).Sum(x => Math.Min(end, x.end) - Math.Max(x.start, start));
                final.DcDuration   = (int)dc.Where(x => x.end >= start && x.start <= end).Sum(x => Math.Min(end, x.end) - Math.Max(x.start, start));
            }
        }