internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases      = GetInitialPhase(log);
            AbstractSingleActor mainTarget  = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.Freezie);
            AbstractSingleActor heartTarget = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TrashID.FreeziesFrozenHeart);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Freezie not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            phases.AddRange(GetPhasesByInvul(log, 895, mainTarget, true, true));
            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                if (i % 2 == 1)
                {
                    phase.Name = "Phase " + (i + 1) / 2;
                    phase.AddTarget(mainTarget);
                }
                else
                {
                    phase.Name = "Heal " + (i) / 2;
                    phase.AddTarget(heartTarget);
                }
            }
            return(phases);
        }
Beispiel #2
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases     = GetInitialPhase(log);
            AbstractSingleActor mainTarget = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.Gorseval);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Gorseval not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            phases.AddRange(GetPhasesByInvul(log, 31877, mainTarget, true, true));
            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                if (i % 2 == 1)
                {
                    phase.Name = "Phase " + (i + 1) / 2;
                    phase.AddTarget(mainTarget);
                }
                else
                {
                    phase.Name = "Split " + (i) / 2;
                    var ids = new List <int>
                    {
                        (int)ArcDPSEnums.TrashID.ChargedSoul
                    };
                    AddTargetsToPhaseAndFit(phase, ids, log);
                }
            }
            return(phases);
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            long                fightDuration = log.FightData.FightEnd;
            List <PhaseData>    phases        = GetInitialPhase(log);
            AbstractSingleActor mainTarget    = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.Slothasor);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Slothasor not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            var  sleepy = mainTarget.GetCastEvents(log, 0, log.FightData.FightEnd).Where(x => x.SkillId == NarcolepsySkill).ToList();
            long start  = 0;
            int  i      = 1;

            foreach (AbstractCastEvent c in sleepy)
            {
                var phase = new PhaseData(start, Math.Min(c.Time, fightDuration), "Phase " + i++);
                phase.AddTarget(mainTarget);
                start = c.EndTime;
                phases.Add(phase);
            }
            var lastPhase = new PhaseData(start, fightDuration, "Phase " + i++);

            lastPhase.AddTarget(mainTarget);
            phases.Add(lastPhase);
            return(phases);
        }
        protected static List <PhaseData> GetPhasesByHealthPercent(ParsedEvtcLog log, NPC mainTarget, List <double> thresholds)
        {
            var phases = new List <PhaseData>();

            if (thresholds.Count == 0)
            {
                return(phases);
            }
            long   fightDuration = log.FightData.FightEnd;
            long   start         = 0;
            double offset        = 100.0 / thresholds.Count;
            IReadOnlyList <HealthUpdateEvent> hpUpdates = log.CombatData.GetHealthUpdateEvents(mainTarget.AgentItem);

            for (int i = 0; i < thresholds.Count; i++)
            {
                HealthUpdateEvent evt = hpUpdates.FirstOrDefault(x => x.HPPercent <= thresholds[i]);
                if (evt == null)
                {
                    break;
                }
                var phase = new PhaseData(start, Math.Min(evt.Time, fightDuration), (offset + thresholds[i]) + "% - " + thresholds[i] + "%");
                phase.AddTarget(mainTarget);
                phases.Add(phase);
                start = Math.Max(evt.Time, 0);
            }
            if (phases.Count > 0 && phases.Count < thresholds.Count)
            {
                var lastPhase = new PhaseData(start, fightDuration, (offset + thresholds[phases.Count]) + "% -" + thresholds[phases.Count] + "%");
                lastPhase.AddTarget(mainTarget);
                phases.Add(lastPhase);
            }
            return(phases);
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases = GetInitialPhase(log);
            AbstractSingleActor cairn  = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.Cairn);

            if (cairn == null)
            {
                throw new MissingKeyActorsException("Cairn not found");
            }
            phases[0].AddTarget(cairn);
            if (!requirePhases)
            {
                return(phases);
            }
            BuffApplyEvent enrageApply = log.CombatData.GetBuffData(EnragedCairn).OfType <BuffApplyEvent>().FirstOrDefault(x => x.To == cairn.AgentItem);

            if (enrageApply != null)
            {
                var normalPhase = new PhaseData(0, enrageApply.Time)
                {
                    Name = "Calm"
                };
                normalPhase.AddTarget(cairn);

                var enragePhase = new PhaseData(enrageApply.Time + 1, log.FightData.FightEnd)
                {
                    Name = "Angry"
                };
                enragePhase.AddTarget(cairn);

                phases.Add(normalPhase);
                phases.Add(enragePhase);
            }
            return(phases);
        }
Beispiel #6
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            long             fightDuration = log.FightData.FightEnd;
            List <PhaseData> phases        = GetInitialPhase(log);
            NPC mainTarget = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.SoullessHorror);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Soulless Horror not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            var  howling = mainTarget.GetCastEvents(log, 0, log.FightData.FightEnd).Where(x => x.SkillId == 48662).ToList();
            long start   = 0;
            int  i       = 1;

            foreach (AbstractCastEvent c in howling)
            {
                var phase = new PhaseData(start, Math.Min(c.Time, fightDuration), "Pre-Breakbar " + i++);
                phase.AddTarget(mainTarget);
                start = c.EndTime;
                phases.Add(phase);
            }
            if (fightDuration - start > 3000)
            {
                var lastPhase = new PhaseData(start, fightDuration, "Final");
                lastPhase.AddTarget(mainTarget);
                phases.Add(lastPhase);
            }
            return(phases);
        }
Beispiel #7
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases  = GetInitialPhase(log);
            AbstractSingleActor maiTrin = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.MaiTrinStrike);

            if (maiTrin == null)
            {
                throw new MissingKeyActorsException("Mai Trin not found");
            }
            phases[0].AddTarget(maiTrin);
            AbstractSingleActor echoOfScarlet = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.EchoOfScarletBriar);

            if (echoOfScarlet != null)
            {
                phases[0].AddTarget(echoOfScarlet);
            }
            if (!requirePhases)
            {
                return(phases);
            }
            if (log.CombatData.GetDamageTakenData(maiTrin.AgentItem).Any())
            {
                HealthUpdateEvent lastHPUpdate = log.CombatData.GetHealthUpdateEvents(maiTrin.AgentItem).LastOrDefault();
                long maiTrinEnd               = lastHPUpdate.Time;
                long maiTrinStart             = 0;
                BuffRemoveAllEvent buffRemove = log.CombatData.GetBuffData(895).OfType <BuffRemoveAllEvent>().Where(x => x.To == maiTrin.AgentItem).FirstOrDefault();
                if (buffRemove != null)
                {
                    maiTrinStart = buffRemove.Time;
                }
                var mainPhase = new PhaseData(0, maiTrinEnd, "Mai Trin");
                mainPhase.AddTarget(maiTrin);
                phases.Add(mainPhase);
                List <PhaseData> maiPhases = GetPhasesByInvul(log, 38793, maiTrin, false, true, maiTrinStart, maiTrinEnd);
                for (int i = 0; i < maiPhases.Count; i++)
                {
                    PhaseData subPhase = maiPhases[i];
                    subPhase.Name = "Mai Trin Phase " + (i + 1);
                    subPhase.AddTarget(maiTrin);
                }
                phases.AddRange(maiPhases);
            }
            if (echoOfScarlet != null)
            {
                long echoStart = echoOfScarlet.FirstAware + 10000;
                var  phase     = new PhaseData(echoStart, log.FightData.FightEnd, "Echo of Scarlet Briar");
                phase.AddTarget(echoOfScarlet);
                phases.Add(phase);
                List <PhaseData> echoPhases = GetPhasesByInvul(log, 38793, echoOfScarlet, false, true, echoStart, log.FightData.FightEnd);
                for (int i = 0; i < echoPhases.Count; i++)
                {
                    PhaseData subPhase = echoPhases[i];
                    subPhase.Name = "Echo Phase " + (i + 1);
                    subPhase.AddTarget(echoOfScarlet);
                }
                phases.AddRange(echoPhases);
            }
            return(phases);
        }
Beispiel #8
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases = GetInitialPhase(log);
            AbstractSingleActor mama   = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.MAMA);

            if (mama == null)
            {
                throw new MissingKeyActorsException("MAMA not found");
            }
            phases[0].AddTarget(mama);
            if (!requirePhases)
            {
                return(phases);
            }
            phases.AddRange(GetPhasesByInvul(log, 762, mama, true, true));
            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                if (i % 2 == 0)
                {
                    var ids = new List <int>
                    {
                        (int)ArcDPSEnums.TrashID.GreenKnight,
                        (int)ArcDPSEnums.TrashID.RedKnight,
                        (int)ArcDPSEnums.TrashID.BlueKnight,
                    };
                    AddTargetsToPhaseAndFit(phase, ids, log);
                    if (phase.Targets.Count > 0)
                    {
                        AbstractSingleActor phaseTar = phase.Targets[0];
                        switch (phaseTar.ID)
                        {
                        case (int)ArcDPSEnums.TrashID.GreenKnight:
                            phase.Name = "Green Knight";
                            break;

                        case (int)ArcDPSEnums.TrashID.RedKnight:
                            phase.Name = "Red Knight";
                            break;

                        case (int)ArcDPSEnums.TrashID.BlueKnight:
                            phase.Name = "Blue Knight";
                            break;

                        default:
                            phase.Name = "Unknown";
                            break;
                        }
                    }
                }
                else
                {
                    phase.Name = "Phase " + (i + 1) / 2;
                    phase.AddTarget(mama);
                }
            }
            return(phases);
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData> phases = GetInitialPhase(log);
            NPC voice = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.ClawOfTheFallen);
            NPC claw  = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.VoiceOfTheFallen);

            if (voice == null || claw == null)
            {
                throw new MissingKeyActorsException("Claw or Voice not found");
            }
            phases[0].AddTarget(voice);
            phases[0].AddTarget(claw);
            long fightEnd = log.FightData.FightEnd;

            if (!requirePhases)
            {
                return(phases);
            }
            //
            List <PhaseData> unmergedPhases = GetPhasesByInvul(log, 762, claw, false, true);

            for (int i = 0; i < unmergedPhases.Count; i++)
            {
                unmergedPhases[i].Name = "Phase " + (i + 1);
                unmergedPhases[i].AddTarget(claw);
                unmergedPhases[i].AddTarget(voice);
            }
            phases.AddRange(unmergedPhases);
            //
            int voiceAndClawCount = 0;
            int offset            = 1;

            foreach (NPC voiceAndClaw in Targets.Where(x => x.ID == (int)ArcDPSEnums.TargetID.VoiceAndClaw))
            {
                EnterCombatEvent enterCombat       = log.CombatData.GetEnterCombatEvents(voiceAndClaw.AgentItem).FirstOrDefault();
                PhaseData        nextUnmergedPhase = unmergedPhases.Count > offset + 1 ? unmergedPhases[offset] : null;
                if (enterCombat != null)
                {
                    var phase = new PhaseData(enterCombat.Time, nextUnmergedPhase != null ? nextUnmergedPhase.Start : Math.Min(fightEnd, voiceAndClaw.LastAware), "Voice and Claw " + ++voiceAndClawCount);
                    phase.AddTarget(voiceAndClaw);
                    phases.Add(phase);
                    offset++;
                }
            }
            //
            AbstractBuffEvent enrage = log.CombatData.GetBuffData(58619).FirstOrDefault(x => x is BuffApplyEvent);

            if (enrage != null)
            {
                var phase = new PhaseData(enrage.Time, log.FightData.FightEnd, "Enrage");
                phase.AddTarget(claw.AgentItem == enrage.To ? claw : voice);
                phases.Add(phase);
            }
            return(phases);
        }
 protected void AddTargetsToPhaseAndFit(PhaseData phase, List <int> ids, ParsedEvtcLog log)
 {
     foreach (NPC target in Targets)
     {
         if (ids.Contains(target.ID) && phase.InInterval(Math.Max(target.FirstAware, 0)))
         {
             phase.AddTarget(target);
         }
     }
     phase.OverrideTimes(log);
 }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases = GetInitialPhase(log);
            AbstractSingleActor ankka  = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.Ankka);

            if (ankka == null)
            {
                throw new MissingKeyActorsException("Ankka not found");
            }
            phases[0].AddTarget(ankka);
            if (!requirePhases)
            {
                return(phases);
            }
            List <PhaseData> subPhases = GetPhasesByInvul(log, AnkkaPlateformChanging, ankka, false, true);

            for (int i = 0; i < subPhases.Count; i++)
            {
                subPhases[i].Name = "Location " + (i + 1);
                subPhases[i].AddTarget(ankka);
            }
            phases.AddRange(subPhases);
            List <PhaseData> subSubPhases = GetPhasesByInvul(log, Determined895, ankka, false, false);

            subSubPhases.RemoveAll(x => subPhases.Any(y => Math.Abs(y.Start - x.Start) < ParserHelper.ServerDelayConstant && Math.Abs(y.End - x.End) < ParserHelper.ServerDelayConstant));
            int       curSubSubPhaseID = 0;
            PhaseData previousSubPhase = null;

            for (int i = 0; i < subSubPhases.Count; i++)
            {
                PhaseData subsubPhase = subSubPhases[i];
                PhaseData subPhase    = subPhases.FirstOrDefault(x => x.Start - ParserHelper.ServerDelayConstant <= subsubPhase.Start && x.End + ParserHelper.ServerDelayConstant >= subsubPhase.End);
                if (previousSubPhase != subPhase)
                {
                    previousSubPhase = subPhase;
                    curSubSubPhaseID = 0;
                }
                if (subPhase != null)
                {
                    int index = subPhases.IndexOf(subPhase);
                    subsubPhase.OverrideStart(Math.Max(subsubPhase.Start, subPhase.Start));
                    subsubPhase.OverrideEnd(Math.Min(subsubPhase.End, subPhase.End));
                    subsubPhase.Name = "Location " + (index + 1) + " - " + (++curSubSubPhaseID);
                    subsubPhase.AddTarget(ankka);
                }
            }
            phases.AddRange(subSubPhases);
            //
            return(phases);
        }
        internal List <PhaseData> GetBreakbarPhases(ParsedEvtcLog log, bool requirePhases)
        {
            if (!requirePhases)
            {
                return(new List <PhaseData>());
            }
            var breakbarPhases = new List <PhaseData>();

            foreach (NPC target in Targets)
            {
                int i = 0;
                IReadOnlyList <BreakbarStateEvent>   breakbarStateEvents   = log.CombatData.GetBreakbarStateEvents(target.AgentItem);
                IReadOnlyList <BreakbarPercentEvent> breakbarPercentEvents = log.CombatData.GetBreakbarPercentEvents(target.AgentItem);
                var breakbarActiveEvents    = breakbarStateEvents.Where(x => x.State == ArcDPSEnums.BreakbarState.Active).ToList();
                var breakbarNotActiveEvents = breakbarStateEvents.Where(x => x.State != ArcDPSEnums.BreakbarState.Active).ToList();
                foreach (BreakbarStateEvent active in breakbarActiveEvents)
                {
                    long start = Math.Max(active.Time - 2000, 0);
                    BreakbarStateEvent notActive = breakbarNotActiveEvents.FirstOrDefault(x => x.Time >= active.Time);
                    long end;
                    if (notActive == null)
                    {
                        DeadEvent deadEvent = log.CombatData.GetDeadEvents(target.AgentItem).LastOrDefault();
                        if (deadEvent == null)
                        {
                            end = Math.Min(target.LastAware, log.FightData.FightEnd);
                        }
                        else
                        {
                            end = Math.Min(deadEvent.Time, log.FightData.FightEnd);
                        }
                    }
                    else
                    {
                        end = Math.Min(notActive.Time, log.FightData.FightEnd);
                    }
                    var phase = new PhaseData(start, end, target.Character + " Breakbar " + ++i)
                    {
                        BreakbarPhase = true,
                        CanBeSubPhase = false
                    };
                    phase.AddTarget(target);
                    breakbarPhases.Add(phase);
                }
            }
            return(breakbarPhases);
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases     = GetInitialPhase(log);
            AbstractSingleActor mainTarget = Targets.FirstOrDefault(x => x.ID == GenericTriggerID);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Golem not found");
            }
            phases[0].Name = "Final Number";
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            IReadOnlyList <HealthUpdateEvent> hpUpdates = log.CombatData.GetHealthUpdateEvents(mainTarget.AgentItem);

            if (hpUpdates.Count > 0)
            {
                long fightDuration = log.FightData.FightEnd;
                var  thresholds    = new List <double> {
                    80, 60, 40, 20, 0
                };
                string[] numberNames = new string[] { "First Number", "Second Number", "Third Number", "Fourth Number" };
                // Fifth number would the equivalent of full fight phase
                for (int j = 0; j < thresholds.Count - 1; j++)
                {
                    HealthUpdateEvent hpUpdate = hpUpdates.FirstOrDefault(x => x.HPPercent <= thresholds[j]);
                    if (hpUpdate != null)
                    {
                        var phase = new PhaseData(0, hpUpdate.Time, numberNames[j])
                        {
                            CanBeSubPhase = false
                        };
                        phase.AddTarget(mainTarget);
                        phases.Add(phase);
                    }
                }
                phases.AddRange(GetPhasesByHealthPercent(log, mainTarget, thresholds));
            }

            return(phases);
        }
Beispiel #14
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            if (!_targetIDs.Any())
            {
                return(base.GetPhases(log, requirePhases));
            }
            List <PhaseData> phases = GetInitialPhase(log);

            phases[0].AddTargets(Targets);
            int phaseCount = 0;

            foreach (NPC target in Targets)
            {
                var phase = new PhaseData(Math.Max(0, target.FirstAware), Math.Min(target.LastAware, log.FightData.FightEnd), "Phase " + (++phaseCount));
                phase.AddTarget(target);
                phases.Add(phase);
            }
            return(phases);
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData> phases = GetInitialPhase(log);
            NPC mainTarget          = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.ValeGuardian);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Vale Guardian not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            // Invul check
            phases.AddRange(GetPhasesByInvul(log, 757, mainTarget, true, true));
            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                if (i % 2 == 0)
                {
                    phase.Name = "Split " + (i) / 2;
                    var ids = new List <int>
                    {
                        (int)ArcDPSEnums.TrashID.BlueGuardian,
                        (int)ArcDPSEnums.TrashID.GreenGuardian,
                        (int)ArcDPSEnums.TrashID.RedGuardian
                    };
                    AddTargetsToPhaseAndFit(phase, ids, log);
                    foreach (NPC t in phase.Targets)
                    {
                        t.OverrideName(t.Character + " " + Math.Log(i, 2));
                    }
                }
                else
                {
                    phase.Name = "Phase " + (i + 1) / 2;
                    phase.AddTarget(mainTarget);
                }
            }
            return(phases);
        }
Beispiel #16
0
        private static List <PhaseData> GetTargetPhases(ParsedEvtcLog log, AbstractSingleActor target, string baseName)
        {
            long start         = 0;
            long end           = 0;
            long fightDuration = log.FightData.FightEnd;
            var  targetPhases  = new List <PhaseData>();
            var  states        = new List <AbstractTimeCombatEvent>();

            states.AddRange(log.CombatData.GetEnterCombatEvents(target.AgentItem));
            states.AddRange(GetFilteredList(log.CombatData, 762, target, true, true).Where(x => x is BuffApplyEvent));
            states.AddRange(log.CombatData.GetDeadEvents(target.AgentItem));
            states.Sort((x, y) => x.Time.CompareTo(y.Time));
            for (int i = 0; i < states.Count; i++)
            {
                AbstractTimeCombatEvent state = states[i];
                if (state is EnterCombatEvent)
                {
                    start = state.Time;
                    if (i == states.Count - 1)
                    {
                        targetPhases.Add(new PhaseData(start, fightDuration));
                    }
                }
                else
                {
                    end = Math.Min(state.Time, fightDuration);
                    targetPhases.Add(new PhaseData(start, end));
                    if (i == states.Count - 1 && targetPhases.Count < 3)
                    {
                        targetPhases.Add(new PhaseData(end, fightDuration));
                    }
                }
            }
            for (int i = 0; i < targetPhases.Count; i++)
            {
                PhaseData phase = targetPhases[i];
                phase.Name = baseName + " P" + (i + 1);
                phase.AddTarget(target);
            }
            return(targetPhases);
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData> phases = GetInitialPhase(log);
            NPC mainTarget          = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.Sabir);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Sabir not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            IReadOnlyList <AbstractCastEvent> cls = mainTarget.GetCastEvents(log, 0, log.FightData.FightEnd);
            var  wallopingWinds = cls.Where(x => x.SkillId == 56094).ToList();
            long start = 0, end = 0;

            for (int i = 0; i < wallopingWinds.Count; i++)
            {
                AbstractCastEvent wallopinbWind = wallopingWinds[i];
                end = wallopinbWind.Time;
                var phase = new PhaseData(start, end, "Phase " + (i + 1));
                phase.AddTarget(mainTarget);
                phases.Add(phase);
                AbstractCastEvent nextAttack = cls.FirstOrDefault(x => x.Time >= wallopinbWind.EndTime && (x.SkillId == 56620 || x.SkillId == 56629 || x.SkillId == 56307));
                if (nextAttack == null)
                {
                    break;
                }
                start = nextAttack.Time;
                if (i == wallopingWinds.Count - 1)
                {
                    phase = new PhaseData(start, log.FightData.FightEnd, "Phase " + (i + 2));
                    phase.AddTarget(mainTarget);
                    phases.Add(phase);
                }
            }

            return(phases);
        }
Beispiel #18
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            long             fightDuration = log.FightData.FightEnd;
            List <PhaseData> phases        = GetInitialPhase(log);
            NPC mainTarget = GetMainTarget();

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Xera not found");
            }
            phases[0].AddTarget(mainTarget);
            if (requirePhases)
            {
                AbstractBuffEvent invulXera = GetInvulXeraEvent(log, mainTarget);
                // split happened
                if (invulXera != null)
                {
                    var phase1 = new PhaseData(0, invulXera.Time, "Phase 1");
                    phase1.AddTarget(mainTarget);
                    phases.Add(phase1);

                    var glidingEndTime = _xeraSecondPhaseStartTime > 0 ? _xeraSecondPhaseStartTime : fightDuration;
                    var glidingPhase   = new PhaseData(invulXera.Time, glidingEndTime, "Gliding");
                    glidingPhase.AddTargets(Targets.Where(t => t.ID == (int)ArcDPSEnums.TrashID.ChargedBloodstone));
                    phases.Add(glidingPhase);

                    if (_xeraSecondPhaseStartTime > 0)
                    {
                        var phase2 = new PhaseData(_xeraSecondPhaseStartTime, fightDuration, "Phase 2");
                        mainTarget.SetManualHealth(24085950);
                        phase2.AddTarget(mainTarget);
                        phase2.AddTargets(Targets.Where(t => t.ID == (int)ArcDPSEnums.TrashID.BloodstoneShard));
                        //mainTarget.AddCustomCastLog(end, -5, (int)(start - end), ParseEnum.Activation.None, (int)(start - end), ParseEnum.Activation.None, log);
                        phases.Add(phase2);
                    }
                }
            }
            return(phases);
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            // generic method for fractals
            List <PhaseData>    phases   = GetInitialPhase(log);
            AbstractSingleActor skorvald = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.Skorvald);

            if (skorvald == null)
            {
                throw new MissingKeyActorsException("Skorvald not found");
            }
            phases[0].AddTarget(skorvald);
            if (!requirePhases)
            {
                return(phases);
            }
            phases.AddRange(GetPhasesByInvul(log, 762, skorvald, true, true));
            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                if (i % 2 == 0)
                {
                    phase.Name = "Split " + (i) / 2;
                    var ids = new List <int>
                    {
                        (int)ArcDPSEnums.TrashID.FluxAnomaly4,
                        (int)ArcDPSEnums.TrashID.FluxAnomaly3,
                        (int)ArcDPSEnums.TrashID.FluxAnomaly2,
                        (int)ArcDPSEnums.TrashID.FluxAnomaly1,
                    };
                    AddTargetsToPhaseAndFit(phase, ids, log);
                }
                else
                {
                    phase.Name = "Phase " + (i + 1) / 2;
                    phase.AddTarget(skorvald);
                }
            }
            return(phases);
        }
Beispiel #20
0
        private static List <PhaseData> GetSubPhases(AbstractSingleActor eye, ParsedEvtcLog log)
        {
            var res = new List <PhaseData>();
            BuffRemoveAllEvent det762Loss = log.CombatData.GetBuffData(SkillIDs.Determined762).OfType <BuffRemoveAllEvent>().Where(x => x.To == eye.AgentItem).FirstOrDefault();

            if (det762Loss != null)
            {
                int  count = 0;
                long start = det762Loss.Time;
                List <AbstractBuffEvent> det895s = GetFilteredList(log.CombatData, Determined895, eye, true, true);
                foreach (AbstractBuffEvent abe in det895s)
                {
                    if (abe is BuffApplyEvent)
                    {
                        var phase = new PhaseData(start, Math.Min(abe.Time, log.FightData.FightDuration))
                        {
                            Name = eye.Character + " " + (++count)
                        };
                        phase.AddTarget(eye);
                        res.Add(phase);
                    }
                    else
                    {
                        start = Math.Min(abe.Time, log.FightData.FightDuration);
                    }
                }
                if (start < log.FightData.FightDuration)
                {
                    var phase = new PhaseData(start, log.FightData.FightDuration)
                    {
                        Name = eye.Character + " " + (++count)
                    };
                    phase.AddTarget(eye);
                    res.Add(phase);
                }
            }
            return(res);
        }
Beispiel #21
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData> phases = GetInitialPhase(log);
            NPC mainTarget          = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.Samarog);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Samarog not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            // Determined check
            phases.AddRange(GetPhasesByInvul(log, 762, mainTarget, true, true));
            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                if (i % 2 == 0)
                {
                    phase.Name = "Split " + i / 2;
                    var ids = new List <int>
                    {
                        (int)ArcDPSEnums.TrashID.Rigom,
                        (int)ArcDPSEnums.TrashID.Guldhem
                    };
                    AddTargetsToPhaseAndFit(phase, ids, log);
                }
                else
                {
                    phase.Name = "Phase " + (i + 1) / 2;
                    phase.AddTarget(mainTarget);
                }
            }
            return(phases);
        }
        public static void SetPhasePerTarget(NPC target, List <PhaseData> phases, ParsedEvtcLog log)
        {
            long             fightDuration = log.FightData.FightEnd;
            EnterCombatEvent phaseStart    = log.CombatData.GetEnterCombatEvents(target.AgentItem).LastOrDefault();

            if (phaseStart != null)
            {
                long      start    = phaseStart.Time;
                DeadEvent phaseEnd = log.CombatData.GetDeadEvents(target.AgentItem).LastOrDefault();
                long      end      = fightDuration;
                if (phaseEnd != null)
                {
                    end = phaseEnd.Time;
                }
                var phase = new PhaseData(start, Math.Min(end, log.FightData.FightEnd));
                phase.AddTarget(target);
                switch (target.ID)
                {
                case (int)ArcDPSEnums.TargetID.Narella:
                    phase.Name = "Narella";
                    break;

                case (int)ArcDPSEnums.TargetID.Berg:
                    phase.Name = "Berg";
                    break;

                case (int)ArcDPSEnums.TargetID.Zane:
                    phase.Name = "Zane";
                    break;

                default:
                    throw new MissingKeyActorsException("Unknown target in Bandit Trio");
                }
                phases.Add(phase);
            }
        }
Beispiel #23
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases     = GetInitialPhase(log);
            AbstractSingleActor mainTarget = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.IcebroodConstruct);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Icebrood Construct not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            // Invul check
            phases.AddRange(GetPhasesByInvul(log, 757, mainTarget, false, true));
            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                phase.Name = "Phase " + i;
                phase.AddTarget(mainTarget);
            }
            return(phases);
        }
Beispiel #24
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData> phases = GetInitialPhase(log);
            var subPhasesData       = new List <(long start, long end, string name, NPC target)>();

            foreach (NPC target in Targets)
            {
                long mainPhaseEnd = Math.Min(target.LastAware, log.FightData.FightEnd);
                switch (target.ID)
                {
                case (int)ArcDPSEnums.TrashID.VoidSaltsprayDragon:
                case (int)ArcDPSEnums.TrashID.VoidTimeCaster:
                case (int)ArcDPSEnums.TrashID.VoidObliterator:
                    subPhasesData.Add((target.FirstAware, mainPhaseEnd, target.Character, target));
                    break;

                case (int)ArcDPSEnums.TargetID.TheDragonVoidJormag:
                    phases[0].AddTarget(target);
                    subPhasesData.Add((target.FirstAware, mainPhaseEnd, "Jormag", target));
                    break;

                case (int)ArcDPSEnums.TargetID.TheDragonVoidKralkatorrik:
                    phases[0].AddTarget(target);
                    subPhasesData.Add((target.FirstAware, mainPhaseEnd, "Kralkatorrik", target));
                    break;

                case (int)ArcDPSEnums.TargetID.TheDragonVoidMordremoth:
                    phases[0].AddTarget(target);
                    subPhasesData.Add((target.FirstAware, mainPhaseEnd, "Mordremoth", target));
                    break;

                case (int)ArcDPSEnums.TargetID.TheDragonVoidPrimordious:
                    phases[0].AddTarget(target);
                    subPhasesData.Add((target.FirstAware, mainPhaseEnd, "Primordious", target));
                    break;

                case (int)ArcDPSEnums.TargetID.TheDragonVoidSooWon:
                    phases[0].AddTarget(target);
                    subPhasesData.Add((target.FirstAware, mainPhaseEnd, "Soo-Won", target));
                    AttackTargetEvent attackTargetEvent = log.CombatData.GetAttackTargetEvents(target.AgentItem).FirstOrDefault();
                    if (attackTargetEvent != null)
                    {
                        var targetables = log.CombatData.GetTargetableEvents(attackTargetEvent.AttackTarget).Where(x => x.Time >= target.FirstAware).ToList();
                        var targetOns   = targetables.Where(x => x.Targetable).ToList();
                        var targetOffs  = targetables.Where(x => !x.Targetable).ToList();
                        int id          = 0;
                        foreach (TargetableEvent targetOn in targetOns)
                        {
                            long            start     = targetOn.Time;
                            long            end       = log.FightData.FightEnd;
                            TargetableEvent targetOff = targetOffs.FirstOrDefault(x => x.Time > start);
                            if (targetOff != null)
                            {
                                end = targetOff.Time;
                            }
                            subPhasesData.Add((start, end, "Soo-Won " + (++id), target));
                        }
                    }
                    break;

                case (int)ArcDPSEnums.TargetID.TheDragonVoidZhaitan:
                    phases[0].AddTarget(target);
                    subPhasesData.Add((target.FirstAware, mainPhaseEnd, "Zhaitan", target));
                    break;

                case (int)ArcDPSEnums.TargetID.DummyTarget:
                    phases[0].AddTarget(target);
                    break;
                }
            }
            if (!requirePhases)
            {
                return(phases);
            }
            foreach ((long start, long end, string name, NPC target)subPhaseData in subPhasesData)
            {
                var subPhase = new PhaseData(subPhaseData.start, subPhaseData.end, subPhaseData.name);
                subPhase.AddTarget(subPhaseData.target);
                phases.Add(subPhase);
            }
            return(phases);
        }
Beispiel #25
0
        private void InitPhases(List <PhaseData> phases, AbstractSingleActor mainTarget,
                                AbstractSingleActor tailTarget, int phaseOffset)
        {
            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                switch (i + phaseOffset)
                {
                case 1:
                    phase.Name = "100% - 80%";
                    phase.AddTarget(mainTarget);
                    break;

                case 2:
                    phase.Name = "First Greens";
                    phase.AddTarget(mainTarget);
                    break;

                case 3:
                    phase.Name = "80% - 60%";
                    phase.AddTarget(mainTarget);
                    phase.AddTarget(tailTarget);
                    break;

                case 4:
                    phase.Name = "First Spear";
                    phase.AddTarget(mainTarget);
                    break;

                case 5:
                    phase.Name = "First Champions";
                    phase.AddTargets(Targets.Where(x =>
                                                   x.ID == (int)ArcDPSEnums.TrashID.VoidGiant2 ||
                                                   x.ID == (int)ArcDPSEnums.TrashID.VoidTimeCaster2));
                    break;

                case 6:
                    phase.Name = "60% - 40%";
                    phase.AddTarget(mainTarget);
                    phase.AddTarget(tailTarget);
                    break;

                case 7:
                    phase.Name = "Second Greens";
                    phase.AddTarget(mainTarget);
                    break;

                case 8:
                    phase.Name = "40% - 20%";
                    phase.AddTarget(mainTarget);
                    phase.AddTarget(tailTarget);
                    break;

                case 9:
                    phase.Name = "Second Spear";
                    phase.AddTarget(mainTarget);
                    break;

                case 10:
                    phase.Name = "Second Champions";
                    phase.AddTargets(Targets.Where(x =>
                                                   x.ID == (int)ArcDPSEnums.TrashID.VoidBrandstalker ||
                                                   x.ID == (int)ArcDPSEnums.TrashID.VoidColdsteel2 ||
                                                   x.ID == (int)ArcDPSEnums.TrashID.VoidObliterator2));
                    break;

                case 11:
                    phase.Name = "20% - 0%";
                    phase.AddTarget(mainTarget);
                    phase.AddTarget(tailTarget);
                    break;
                }
            }
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases  = GetInitialPhase(log);
            AbstractSingleActor fraenir = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.FraenirOfJormag);

            if (fraenir == null)
            {
                throw new MissingKeyActorsException("Fraenir of Jormag not found");
            }
            phases[0].AddTarget(fraenir);
            AbstractSingleActor icebrood = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.IcebroodConstructFraenir);

            if (icebrood != null)
            {
                phases[0].AddTarget(icebrood);
            }
            if (!requirePhases)
            {
                return(phases);
            }
            AbstractBuffEvent invulApplyFraenir = log.CombatData.GetBuffData(762).Where(x => x.To == fraenir.AgentItem && x is BuffApplyEvent).FirstOrDefault();

            if (invulApplyFraenir != null)
            {
                // split happened
                phases.Add(new PhaseData(0, invulApplyFraenir.Time, "Fraenir 1"));
                if (icebrood != null)
                {
                    // icebrood enters combat
                    EnterCombatEvent enterCombatIce = log.CombatData.GetEnterCombatEvents(icebrood.AgentItem).LastOrDefault();
                    if (enterCombatIce != null)
                    {
                        // icebrood phasing
                        AbstractBuffEvent invulApplyIce  = log.CombatData.GetBuffData(757).Where(x => x.To == icebrood.AgentItem && x is BuffApplyEvent).FirstOrDefault();
                        AbstractBuffEvent invulRemoveIce = log.CombatData.GetBuffData(757).Where(x => x.To == icebrood.AgentItem && x is BuffRemoveAllEvent).FirstOrDefault();
                        long icebroodStart = enterCombatIce.Time;
                        long icebroodEnd   = log.FightData.FightEnd;
                        if (invulApplyIce != null && invulRemoveIce != null)
                        {
                            long icebrood2Start = invulRemoveIce.Time;
                            phases.Add(new PhaseData(icebroodStart + 1, invulApplyIce.Time, "Icebrood 1"));
                            AbstractBuffEvent invulRemoveFraenir = log.CombatData.GetBuffData(762).Where(x => x.To == fraenir.AgentItem && x is BuffRemoveAllEvent).FirstOrDefault();
                            if (invulRemoveFraenir != null)
                            {
                                // fraenir came back
                                DeadEvent deadIce = log.CombatData.GetDeadEvents(icebrood.AgentItem).LastOrDefault();
                                if (deadIce != null)
                                {
                                    icebroodEnd = deadIce.Time;
                                }
                                else
                                {
                                    icebroodEnd = invulRemoveFraenir.Time - 1;
                                }
                                phases.Add(new PhaseData(invulRemoveFraenir.Time, log.FightData.FightEnd, "Fraenir 2"));
                            }
                            phases.Add(new PhaseData(icebrood2Start, icebroodEnd, "Icebrood 2"));
                        }
                        phases.Add(new PhaseData(icebroodStart, icebroodEnd, "Icebrood"));
                    }
                }
            }
            phases.Sort((x, y) => x.Start.CompareTo(y.Start));
            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                if (i == 1 || i == 5)
                {
                    phase.AddTarget(fraenir);
                }
                else
                {
                    phase.AddTarget(icebrood);
                }
            }
            return(phases);
        }
Beispiel #27
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData> phases = GetInitialPhase(log);
            NPC mainTarget          = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.PeerlessQadim);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Peerless Qadim not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            var phaseStarts = new List <long>();
            var phaseEnds   = new List <long>();
            //
            var magmaDrops = log.CombatData.GetBuffData(56475).Where(x => x is BuffApplyEvent).ToList();

            foreach (AbstractBuffEvent magmaDrop in magmaDrops)
            {
                if (phaseEnds.Count > 0)
                {
                    if (Math.Abs(phaseEnds.Last() - magmaDrop.Time) > 1000)
                    {
                        phaseEnds.Add(magmaDrop.Time);
                    }
                }
                else
                {
                    phaseEnds.Add(magmaDrop.Time);
                }
            }
            IReadOnlyList <AnimatedCastEvent> pushes = log.CombatData.GetAnimatedCastData(56405);

            if (pushes.Count > 0)
            {
                AbstractCastEvent push = pushes[0];
                phaseStarts.Add(push.EndTime);
                foreach (long magmaDrop in phaseEnds)
                {
                    push = pushes.FirstOrDefault(x => x.Time >= magmaDrop);
                    if (push == null)
                    {
                        break;
                    }
                    phaseStarts.Add(push.EndTime);
                }
            }
            // rush to pylon
            phaseEnds.AddRange(log.CombatData.GetAnimatedCastData(56616).Select(x => x.Time).ToList());
            phaseEnds.Add(log.FightData.FightEnd);
            // tp to middle after pylon destruction
            phaseStarts.AddRange(log.CombatData.GetAnimatedCastData(56375).Select(x => x.EndTime));
            if (phaseEnds.Count < phaseStarts.Count)
            {
                return(phases);
            }
            for (int i = 0; i < phaseStarts.Count; i++)
            {
                var phase = new PhaseData(phaseStarts[i], phaseEnds[i], "Phase " + (i + 1));
                phase.AddTarget(mainTarget);
                phases.Add(phase);
            }
            return(phases);
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases     = GetInitialPhase(log);
            AbstractSingleActor mainTarget = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.Sabetha);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Sabetha not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            // Invul check
            phases.AddRange(GetPhasesByInvul(log, 757, mainTarget, true, true));
            var ids = new List <int>
            {
                (int)ArcDPSEnums.TrashID.Kernan,
                (int)ArcDPSEnums.TrashID.Knuckles,
                (int)ArcDPSEnums.TrashID.Karde,
            };

            for (int i = 1; i < phases.Count; i++)
            {
                PhaseData phase = phases[i];
                if (i % 2 == 0)
                {
                    AddTargetsToPhaseAndFit(phase, ids, log);
                    if (phase.Targets.Count > 0)
                    {
                        AbstractSingleActor phaseTar = phase.Targets[0];
                        switch (phaseTar.ID)
                        {
                        case (int)ArcDPSEnums.TrashID.Kernan:
                            phase.Name = "Kernan";
                            break;

                        case (int)ArcDPSEnums.TrashID.Knuckles:
                            phase.Name = "Knuckles";
                            break;

                        case (int)ArcDPSEnums.TrashID.Karde:
                            phase.Name = "Karde";
                            break;

                        default:
                            phase.Name = "Unknown";
                            break;
                        }
                    }
                }
                else
                {
                    phase.Name = "Phase " + (i + 1) / 2;
                    phase.AddTarget(mainTarget);
                    AddTargetsToPhaseAndFit(phase, ids, log);
                }
            }
            return(phases);
        }
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases     = GetInitialPhase(log);
            AbstractSingleActor mainTarget = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.PeerlessQadim);

            if (mainTarget == null)
            {
                throw new MissingKeyActorsException("Peerless Qadim not found");
            }
            phases[0].AddTarget(mainTarget);
            if (!requirePhases)
            {
                return(phases);
            }
            var phaseStarts = new List <long>();
            var phaseEnds   = new List <long>();
            //
            var magmaDrops = log.CombatData.GetBuffData(MagmaDrop).Where(x => x is BuffApplyEvent).ToList();

            foreach (AbstractBuffEvent magmaDrop in magmaDrops)
            {
                if (phaseEnds.Count > 0)
                {
                    if (Math.Abs(phaseEnds.Last() - magmaDrop.Time) > 1000)
                    {
                        phaseEnds.Add(magmaDrop.Time);
                    }
                }
                else
                {
                    phaseEnds.Add(magmaDrop.Time);
                }
            }
            IReadOnlyList <AnimatedCastEvent> pushes = log.CombatData.GetAnimatedCastData(ForceOfRetaliationCast);

            if (pushes.Count > 0)
            {
                AbstractCastEvent push = pushes[0];
                phaseStarts.Add(push.Time);
                foreach (long magmaDrop in phaseEnds)
                {
                    push = pushes.FirstOrDefault(x => x.Time >= magmaDrop);
                    if (push == null)
                    {
                        break;
                    }
                    phaseStarts.Add(push.Time);
                }
            }
            // rush to pylon
            phaseEnds.AddRange(log.CombatData.GetAnimatedCastData(BatteringBlitz).Select(x => x.Time).ToList());
            phaseEnds.Add(log.FightData.FightEnd);
            // tp to middle after pylon destruction
            phaseStarts.AddRange(log.CombatData.GetAnimatedCastData(PeerlessQadimTPCenter).Select(x => x.EndTime));
            // There should be at least as many starts as ends, otherwise skip phases
            if (phaseEnds.Count < phaseStarts.Count)
            {
                return(phases);
            }
            for (int i = 0; i < phaseStarts.Count; i++)
            {
                var phase = new PhaseData(phaseStarts[i], phaseEnds[i], "Phase " + (i + 1));
                phase.AddTarget(mainTarget);
                phases.Add(phase);
            }
            // intermission phase never finished, add a "dummy" log end
            if (phaseEnds.Count - 1 == phaseStarts.Count)
            {
                phaseStarts.Add(log.FightData.FightEnd);
            }
            // There should be as many ends as starts, otherwise anomaly, skip intermission phases
            if (phaseEnds.Count != phaseStarts.Count)
            {
                return(phases);
            }
            string[] intermissionNames = { "Magma Drop 1", "Magma Drop 2", "North Pylon", "SouthWest Pylon", "SouthEast Pylon" };
            bool     skipNames         = intermissionNames.Length < phaseEnds.Count - 1;

            for (int i = 0; i < phaseEnds.Count - 1; i++)
            {
                var phase = new PhaseData(phaseEnds[i], Math.Min(phaseStarts[i + 1], log.FightData.FightEnd), skipNames ? "Intermission " + (i + 1) : intermissionNames[i]);
                phase.AddTarget(mainTarget);
                phases.Add(phase);
            }
            return(phases);
        }
Beispiel #30
0
        internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
        {
            List <PhaseData>    phases = GetInitialPhase(log);
            AbstractSingleActor ca     = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.ConjuredAmalgamate);

            if (ca == null)
            {
                throw new MissingKeyActorsException("Conjured Amalgamate not found");
            }
            phases[0].AddTarget(ca);
            if (!requirePhases)
            {
                return(phases);
            }
            phases.AddRange(GetPhasesByInvul(log, 52255, ca, true, false));
            for (int i = 1; i < phases.Count; i++)
            {
                string    name;
                PhaseData phase = phases[i];
                if (i % 2 == 1)
                {
                    name = "Arm Phase";
                }
                else
                {
                    name = "Burn Phase";
                    phase.AddTarget(ca);
                }
                phase.Name = name;
            }
            AbstractSingleActor leftArm = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.CALeftArm);

            if (leftArm != null)
            {
                List <long> targetables = GetTargetableTimes(log, leftArm);
                for (int i = 1; i < phases.Count; i += 2)
                {
                    PhaseData phase = phases[i];
                    if (targetables.Exists(x => phase.InInterval(x)))
                    {
                        phase.Name = "Left " + phase.Name;
                        phase.AddTarget(leftArm);
                    }
                }
            }
            AbstractSingleActor rightArm = Targets.FirstOrDefault(x => x.ID == (int)ArcDPSEnums.TargetID.CARightArm);

            if (rightArm != null)
            {
                List <long> targetables = GetTargetableTimes(log, rightArm);
                for (int i = 1; i < phases.Count; i += 2)
                {
                    PhaseData phase = phases[i];
                    if (targetables.Exists(x => phase.InInterval(x)))
                    {
                        if (phase.Name.Contains("Left"))
                        {
                            phase.Name = "Both Arms Phase";
                        }
                        else
                        {
                            phase.Name = "Right " + phase.Name;
                        }
                        phase.AddTarget(rightArm);
                    }
                }
            }
            return(phases);
        }