public override List <PhaseData> GetPhases(ParsedLog log, bool requirePhases)
{
List <PhaseData> phases = GetInitialPhase(log);
NPC mainTarget = Targets.Find(x => x.ID == (int)ParseEnum.TargetIDS.Samarog);
if (mainTarget == null)
{
throw new InvalidOperationException("Samarog not found");
}
phases[0].Targets.Add(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)Rigom,
(int)Guldhem
};
AddTargetsToPhase(phase, ids, log);
foreach (NPC t in phase.Targets)
{
t.OverrideName(t.Character + " " + i / 2);
}
}
else
{
phase.Name = "Phase " + (i + 1) / 2;
phase.Targets.Add(mainTarget);
}
}
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.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);
foreach (NPC t in phase.Targets)
{
t.OverrideName(t.Character + " " + i / 2);
}
}
else
{
phase.Name = "Phase " + (i + 1) / 2;
phase.AddTarget(mainTarget);
}
}
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.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);
}
public override List <PhaseData> GetPhases(ParsedLog log, bool requirePhases)
{
long fightDuration = log.FightData.FightDuration;
List <PhaseData> phases = GetInitialPhase(log);
Target mainTarget = Targets.Find(x => x.ID == (ushort)ParseEnum.TargetIDS.SoullessHorror);
if (mainTarget == null)
{
throw new InvalidOperationException("Main target of the fight not found");
}
phases[0].Targets.Add(mainTarget);
if (!requirePhases)
{
return(phases);
}
List <CastLog> howling = mainTarget.GetCastLogs(log, 0, log.FightData.FightDuration).Where(x => x.SkillId == 48662).ToList();
long start = 0;
int i = 1;
foreach (CastLog c in howling)
{
PhaseData phase = new PhaseData(start, Math.Min(c.Time, fightDuration))
{
Name = "Pre-Breakbar " + i++
};
phase.Targets.Add(mainTarget);
start = c.Time + c.ActualDuration;
phases.Add(phase);
}
if (fightDuration - start > 3000)
{
PhaseData lastPhase = new PhaseData(start, fightDuration)
{
Name = "Final"
};
lastPhase.Targets.Add(mainTarget);
phases.Add(lastPhase);
}
phases.RemoveAll(x => x.GetDuration() <= 1000);
return(phases);
}
public override List <PhaseData> GetPhases(ParsedLog log, bool requirePhases)
{
List <PhaseData> phases = GetInitialPhase(log);
NPC mainTarget = Targets.Find(x => x.ID == (int)ParseEnum.TargetIDS.Sabir);
if (mainTarget == null)
{
throw new InvalidOperationException("Sabir not found");
}
phases[0].Targets.Add(mainTarget);
if (!requirePhases)
{
return(phases);
}
List <AbstractCastEvent> cls = mainTarget.GetCastLogs(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 wW = wallopingWinds[i];
end = wW.Time;
var phase = new PhaseData(start, end, "Phase " + (i + 1));
phase.Targets.Add(mainTarget);
phases.Add(phase);
AbstractCastEvent nextAttack = cls.FirstOrDefault(x => x.Time >= end + wW.ActualDuration && (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.Targets.Add(mainTarget);
phases.Add(phase);
}
}
return(phases);
}
private static List <PhaseData> GetTargetPhases(ParsedLog log, NPC 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).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.Targets.Add(target);
}
return(targetPhases);
}
public override List <PhaseData> GetPhases(ParsedLog log, bool requirePhases)
{
List <PhaseData> phases = GetInitialPhase(log);
NPC mama = Targets.Find(x => x.ID == (int)ParseEnum.TargetIDS.MAMA);
if (mama == null)
{
throw new InvalidOperationException("Error Encountered: MAMA not found");
}
phases[0].Targets.Add(mama);
if (!requirePhases)
{
return(phases);
}
phases.AddRange(GetPhasesByInvul(log, 762, mama, true, true));
string[] namesMAMA = new[] { "Phase 1", "Red Knight", "Phase 2", "Green Knight", "Phase 3", "Blue Knight", "Phase 4" };
if (phases.Count - 1 > namesMAMA.Length)
{
throw new InvalidOperationException("Error Encountered: too many phases on MAMA");
}
for (int i = 1; i < phases.Count; i++)
{
PhaseData phase = phases[i];
phase.Name = namesMAMA[i - 1];
if (i == 2 || i == 4 || i == 6)
{
var ids = new List <int>
{
(int)GreenKnight,
(int)RedKnight,
(int)BlueKnight,
};
AddTargetsToPhase(phase, ids, log);
}
else
{
phase.Targets.Add(mama);
}
}
return(phases);
}
public static List <PlayerChartDataDto> BuildPlayersGraphData(ParsedLog log, int phaseIndex)
{
var list = new List <PlayerChartDataDto>();
PhaseData phase = log.FightData.GetPhases(log)[phaseIndex];
foreach (Player p in log.PlayerList)
{
var pChar = new PlayerChartDataDto()
{
Total = p.Get1SDamageList(log, phaseIndex, phase, null),
Targets = new List <List <int> >(),
HealthStates = ChartDataDto.BuildHealthGraphStates(log, p, log.FightData.GetPhases(log)[phaseIndex], true)
};
foreach (NPC target in phase.Targets)
{
pChar.Targets.Add(p.Get1SDamageList(log, phaseIndex, phase, target));
}
list.Add(pChar);
}
return(list);
}
PhaseData CopyPhaseData()
{
//Copy over the phase data to the struct for player data.
data = new PhaseData();
data.ComboToComplete = ComboCompletionRequirement;
data.BossesToComplete = BossCompletionRequirement;
data.WavesToBoss = WaveCountForBoss;
data.ScoreMultiplier = ScoreMultiplier;
data.Description = Description;
data.IconTextureName = IconTextureName;
data.Label = "Phase Name: " + this.name;
data.PhaseStatistics = GameObjectTracker.GetGOT().PushStatistics("PhaseStat_" + this.name, ScoreMultiplier);
//Set the name of the phase so we can find in the scene view easily.
name = "GamePhase_" + name;
return(data);
}
private FinalDPS GetFinalDPS(AbstractPlayer player, int phaseIndex, Boss target)
{
PhaseData phase = _statistics.Phases[phaseIndex];
double phaseDuration = (phase.GetDuration()) / 1000.0;
double damage;
double dps = 0.0;
FinalDPS final = new FinalDPS();
//DPS
damage = player.GetDamageLogs(target, _log,
phase.Start, phase.End).Sum(x => x.Damage);
if (phaseDuration > 0)
{
dps = damage / phaseDuration;
}
final.Dps = (int)dps;
final.Damage = (int)damage;
//Condi DPS
damage = player.GetDamageLogs(target, _log,
phase.Start, phase.End).Where(x => x.IsCondi > 0).Sum(x => x.Damage);
if (phaseDuration > 0)
{
dps = damage / phaseDuration;
}
final.CondiDps = (int)dps;
final.CondiDamage = (int)damage;
//Power DPS
damage = final.Damage - final.CondiDamage;
if (phaseDuration > 0)
{
dps = damage / phaseDuration;
}
final.PowerDps = (int)dps;
final.PowerDamage = (int)damage;
final.PlayerPowerDamage = player.GetJustPlayerDamageLogs(target, _log,
phase.Start, phase.End).Where(x => x.IsCondi == 0).Sum(x => x.Damage);
return(final);
}
private List <PhaseData> GetTargetPhases(ParsedLog log, Target target, string[] names)
{
long start = 0;
long end = 0;
long fightDuration = log.FightData.FightDuration;
List <PhaseData> targetPhases = new List <PhaseData>();
List <CombatItem> states = log.CombatData.GetStatesData(target.InstID, ParseEnum.StateChange.EnterCombat, target.FirstAware, target.LastAware);
states.AddRange(GetFilteredList(log, 762, target, true).Where(x => x.IsBuffRemove == ParseEnum.BuffRemove.None));
states.AddRange(log.CombatData.GetStatesData(target.InstID, ParseEnum.StateChange.ChangeDead, target.FirstAware, target.LastAware));
states.Sort((x, y) => x.Time.CompareTo(y.Time));
for (int i = 0; i < states.Count; i++)
{
CombatItem state = states[i];
if (state.IsStateChange == ParseEnum.StateChange.EnterCombat)
{
start = log.FightData.ToFightSpace(state.Time);
if (i == states.Count - 1)
{
targetPhases.Add(new PhaseData(start, fightDuration));
}
}
else
{
end = Math.Min(log.FightData.ToFightSpace(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 = names[i];
phase.Targets.Add(target);
}
return(targetPhases);
}
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);
}
public override List <PhaseData> GetPhases(ParsedLog log, bool requirePhases)
{
long fightDuration = log.FightData.FightDuration;
List <PhaseData> phases = GetInitialPhase(log);
Target mainTarget = Targets.Find(x => x.ID == (ushort)ParseEnum.TargetIDS.Slothasor);
if (mainTarget == null)
{
throw new InvalidOperationException("Main target of the fight not found");
}
phases[0].Targets.Add(mainTarget);
if (!requirePhases)
{
return(phases);
}
List <AbstractCastEvent> sleepy = mainTarget.GetCastLogs(log, 0, log.FightData.FightDuration).Where(x => x.SkillId == 34515).ToList();
long start = 0;
int i = 1;
foreach (AbstractCastEvent c in sleepy)
{
PhaseData phase = new PhaseData(start, Math.Min(c.Time, fightDuration))
{
Name = "Phase " + i++
};
phase.Targets.Add(mainTarget);
start = c.Time + c.ActualDuration;
phases.Add(phase);
}
PhaseData lastPhase = new PhaseData(start, fightDuration)
{
Name = "Phase " + i++
};
lastPhase.Targets.Add(mainTarget);
phases.Add(lastPhase);
phases.RemoveAll(x => x.DurationInMS <= 1000);
return(phases);
}
public void calculateConditions()
{
statistics.bossConditions = new Dictionary <int, Statistics.FinalBossBoon> [phases.Count];
List <Boon> boon_to_track = Boon.getCondiBoonList();
boon_to_track.AddRange(Boon.getBoonList());
for (int phaseIndex = 0; phaseIndex < phases.Count; phaseIndex++)
{
List <PhaseData> phases = log.getBoss().getPhases(log, settings.ParsePhases);
BoonDistribution boonDistribution = log.getBoss().getBoonDistribution(log, phases, boon_to_track, phaseIndex);
Dictionary <int, Statistics.FinalBossBoon> rates = new Dictionary <int, Statistics.FinalBossBoon>();
PhaseData phase = phases[phaseIndex];
long fightDuration = phase.getDuration();
foreach (Boon boon in Boon.getCondiBoonList())
{
Statistics.FinalBossBoon condition = new Statistics.FinalBossBoon();
rates[boon.getID()] = condition;
if (boonDistribution.ContainsKey(boon.getID()))
{
if (boon.getType() == Boon.BoonType.Duration)
{
condition.boonType = Boon.BoonType.Duration;
condition.uptime = Math.Round(100.0 * boonDistribution.getUptime(boon.getID()) / fightDuration, 1);
}
else if (boon.getType() == Boon.BoonType.Intensity)
{
condition.boonType = Boon.BoonType.Intensity;
condition.uptime = Math.Round((double)boonDistribution.getUptime(boon.getID()) / fightDuration, 1);
}
rates[boon.getID()] = condition;
}
}
statistics.bossConditions[phaseIndex] = rates;
}
}
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);
}
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;
PhaseData phase = _phases[phaseIndex];
foreach (Player player in _noFakePlayers)
{
FinalDefensesAll defenses = player.GetDefenseStats(_log, phase.Start, phase.End);
WriteLine(new[] { player.Group.ToString(), player.Spec.ToString(), 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 static List <object> GetDefenseStatData(FinalDefensesAll defenses, PhaseData phase)
{
var data = new List <object>
{
defenses.DamageTaken,
defenses.DamageBarrier,
defenses.MissedCount,
defenses.InterruptedCount,
defenses.InvulnedCount,
defenses.EvadedCount,
defenses.BlockedCount,
defenses.DodgeCount,
};
if (defenses.DownDuration > 0)
{
var downDuration = TimeSpan.FromMilliseconds(defenses.DownDuration);
data.Add(defenses.DownCount);
data.Add(downDuration.TotalSeconds + " seconds downed, " + Math.Round((downDuration.TotalMilliseconds / phase.DurationInMS) * 100, 1) + "% Downed");
}
else
{
data.Add(0);
data.Add("0% downed");
}
if (defenses.DeadCount > 0)
{
var deathDuration = TimeSpan.FromMilliseconds(defenses.DeadDuration);
data.Add(defenses.DeadCount);
data.Add(deathDuration.TotalSeconds + " seconds dead, " + (100.0 - Math.Round((deathDuration.TotalMilliseconds / phase.DurationInMS) * 100, 1)) + "% Alive");
}
else
{
data.Add(0);
data.Add("100% Alive");
}
return(data);
}
private FinalDPS GetFinalDPS(AbstractActor player, int phaseIndex, Target target)
{
PhaseData phase = _statistics.Phases[phaseIndex];
double phaseDuration = (phase.GetDuration()) / 1000.0;
int damage;
double dps = 0.0;
FinalDPS final = new FinalDPS();
//DPS
damage = player.GetDamageLogs(target, _log,
phase.Start, phase.End).Sum(x => x.Damage);
if (phaseDuration > 0)
{
dps = damage / phaseDuration;
}
final.Dps = (int)Math.Round(dps);
final.Damage = damage;
//Condi DPS
damage = player.GetDamageLogs(target, _log,
phase.Start, phase.End).Sum(x => x.IsCondi ? x.Damage : 0);
if (phaseDuration > 0)
{
dps = damage / phaseDuration;
}
final.CondiDps = (int)Math.Round(dps);
final.CondiDamage = damage;
//Power DPS
damage = final.Damage - final.CondiDamage;
if (phaseDuration > 0)
{
dps = damage / phaseDuration;
}
final.PowerDps = (int)Math.Round(dps);
final.PowerDamage = damage;
return(final);
}
public override List <PhaseData> GetPhases(ParsedLog log, bool requirePhases)
{
List <PhaseData> phases = GetInitialPhase(log);
Target mainTarget = Targets.Find(x => x.ID == (ushort)ParseEnum.TargetIDS.ValeGuardian);
if (mainTarget == null)
{
throw new InvalidOperationException("Main target of the fight not found");
}
phases[0].Targets.Add(mainTarget);
if (!requirePhases)
{
return(phases);
}
// Invul check
phases.AddRange(GetPhasesByInvul(log, 757, mainTarget, true, true));
string[] namesVG = new[] { "Phase 1", "Split 1", "Phase 2", "Split 2", "Phase 3" };
for (int i = 1; i < phases.Count; i++)
{
PhaseData phase = phases[i];
phase.Name = namesVG[i - 1];
if (i == 2 || i == 4)
{
List <ushort> ids = new List <ushort>
{
(ushort)BlueGuardian,
(ushort)GreenGuardian,
(ushort)RedGuardian
};
AddTargetsToPhase(phase, ids, log);
}
else
{
phase.Targets.Add(mainTarget);
}
}
return(phases);
}
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);
}
internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
{
List <PhaseData> phases = GetInitialPhase(log);
AbstractSingleActor 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);
}
else
{
phase.Name = "Phase " + (i + 1) / 2;
phase.AddTarget(mainTarget);
}
}
return(phases);
}
private void CreateSupTable(int phaseIndex)
{
PhaseData phase = _phases[phaseIndex];
//generate supstats table
WriteLine(new[] { "Sub Group", "Profession", "Name",
"Condi Cleanse", "Condi Cleanse time", "Condi Cleanse Self", "Condi Cleanse time self", "Boon Strips", "Boon Strips time", "Resurrects", "Time Resurecting" });
int count = 0;
foreach (Player player in _noFakePlayers)
{
FinalToPlayersSupport support = player.GetToPlayerSupportStats(_log, phase.Start, phase.End);
WriteLine(new[] { player.Group.ToString(), player.Spec.ToString(), player.Character,
support.CondiCleanse.ToString(), support.CondiCleanseTime.ToString(), support.CondiCleanseSelf.ToString(), support.CondiCleanseTimeSelf.ToString(), support.BoonStrips.ToString(), support.BoonStripsTime.ToString(), support.Resurrects.ToString(), support.ResurrectTime.ToString() });
count++;
}
while (count < 15)//so each graph has equal spacing
{
NewLine();
count++;
}
}
private static void AddSplitPhase(List <PhaseData> phases, IReadOnlyList <AbstractSingleActor> targets, AbstractSingleActor ministerLi, ParsedEvtcLog log, int phaseID)
{
if (targets.All(x => x != null))
{
EnterCombatEvent cbtEnter = null;
foreach (NPC target in targets)
{
cbtEnter = log.CombatData.GetEnterCombatEvents(target.AgentItem).LastOrDefault();
if (cbtEnter != null)
{
break;
}
}
if (cbtEnter != null)
{
AbstractBuffEvent nextPhaseStartEvt = log.CombatData.GetBuffData(ministerLi.AgentItem).FirstOrDefault(x => x is BuffRemoveAllEvent && x.BuffID == 762 && x.Time > cbtEnter.Time);
long phaseEnd = nextPhaseStartEvt != null ? nextPhaseStartEvt.Time : log.FightData.FightEnd;
var addPhase = new PhaseData(cbtEnter.Time, phaseEnd, "Split Phase " + phaseID);
addPhase.AddTargets(targets);
phases.Add(addPhase);
}
}
}
internal static List <BuffChartDataDto> BuildBoonGraphData(ParsedEvtcLog log, AbstractSingleActor p, int phaseIndex, Dictionary <long, Buff> usedBuffs)
{
var list = new List <BuffChartDataDto>();
PhaseData phase = log.FightData.GetPhases(log)[phaseIndex];
var boonGraphData = p.GetBuffGraphs(log).ToDictionary(x => x.Key, x => x.Value);
BuildBoonGraphData(list, log.Statistics.PresentBoons, boonGraphData, phase, usedBuffs);
BuildBoonGraphData(list, log.Statistics.PresentConditions, boonGraphData, phase, usedBuffs);
BuildBoonGraphData(list, log.Statistics.PresentOffbuffs, boonGraphData, phase, usedBuffs);
BuildBoonGraphData(list, log.Statistics.PresentSupbuffs, boonGraphData, phase, usedBuffs);
BuildBoonGraphData(list, log.Statistics.PresentDefbuffs, boonGraphData, phase, usedBuffs);
foreach (BuffsGraphModel bgm in boonGraphData.Values)
{
BuffChartDataDto graph = BuildBuffGraph(bgm, phase, usedBuffs);
if (graph != null)
{
list.Add(graph);
}
}
if (p.GetType() == typeof(Player))
{
foreach (NPC mainTarget in log.FightData.GetMainTargets(log))
{
boonGraphData = mainTarget.GetBuffGraphs(log);
foreach (BuffsGraphModel bgm in boonGraphData.Values.Reverse().Where(x => x.Buff.Name == "Compromised" || x.Buff.Name == "Unnatural Signet" || x.Buff.Name == "Fractured - Enemy" || x.Buff.Name == "Erratic Energy"))
{
BuffChartDataDto graph = BuildBuffGraph(bgm, phase, usedBuffs);
if (graph != null)
{
list.Add(graph);
}
}
}
}
list.Reverse();
return(list);
}
public static JsonPhase BuildJsonPhase(PhaseData phase, ParsedEvtcLog log)
{
var jsPhase = new JsonPhase();
jsPhase.Start = phase.Start;
jsPhase.End = phase.End;
jsPhase.Name = phase.Name;
var targets = new List <int>();
jsPhase.BreakbarPhase = phase.BreakbarPhase;
foreach (AbstractSingleActor tar in phase.Targets)
{
targets.Add(log.FightData.Logic.Targets.IndexOf(tar));
}
jsPhase.Targets = targets;
IReadOnlyList <PhaseData> phases = log.FightData.GetNonDummyPhases(log);
if (!jsPhase.BreakbarPhase)
{
var subPhases = new List <int>();
for (int j = 1; j < phases.Count; j++)
{
PhaseData curPhase = phases[j];
if (curPhase.Start < jsPhase.Start || curPhase.End > jsPhase.End ||
(curPhase.Start == jsPhase.Start && curPhase.End == jsPhase.End) || !curPhase.CanBeSubPhase)
{
continue;
}
subPhases.Add(j);
}
if (subPhases.Any())
{
jsPhase.SubPhases = subPhases;
}
}
return(jsPhase);
}
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);
}
internal override List <PhaseData> GetPhases(ParsedEvtcLog log, bool requirePhases)
{
List <PhaseData> phases = GetInitialPhase(log);
NPC mainTarget = Targets.Find(x => x.ID == (int)ArcDPSEnums.TargetID.IcebroodConstruct);
if (mainTarget == null)
{
throw new InvalidOperationException("Icebrood Construct not found");
}
phases[0].Targets.Add(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.Targets.Add(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.Targets.Add(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 InvalidOperationException("Unknown target in Bandit Trio");
}
phases.Add(phase);
}
}
internal JsonPlayer(Player player, ParsedEvtcLog log, RawFormatSettings settings, Dictionary <string, JsonLog.SkillDesc> skillDesc, Dictionary <string, JsonLog.BuffDesc> buffDesc, Dictionary <string, JsonLog.DamageModDesc> damageModDesc, Dictionary <string, HashSet <long> > personalBuffs) : base(player, log, settings, skillDesc, buffDesc)
{
IReadOnlyList <PhaseData> phases = log.FightData.GetPhases(log);
//
Account = player.Account;
Weapons = player.GetWeaponsArray(log).Select(w => w ?? "Unknown").ToArray();
Group = player.Group;
Profession = player.Prof;
ActiveTimes = phases.Select(x => player.GetActiveDuration(log, x.Start, x.End)).ToList();
HasCommanderTag = player.HasCommanderTag;
//
Support = phases.Select(phase => new JsonStatistics.JsonPlayerSupport(player.GetPlayerSupportStats(log, phase.Start, phase.End))).ToArray();
var targetDamage1S = new IReadOnlyList <int> [log.FightData.Logic.Targets.Count][];
var targetPowerDamage1S = new IReadOnlyList <int> [log.FightData.Logic.Targets.Count][];
var targetConditionDamage1S = new IReadOnlyList <int> [log.FightData.Logic.Targets.Count][];
var targetBreakbarDamage1S = new IReadOnlyList <double> [log.FightData.Logic.Targets.Count][];
var dpsTargets = new JsonStatistics.JsonDPS[log.FightData.Logic.Targets.Count][];
var statsTargets = new JsonStatistics.JsonGameplayStats[log.FightData.Logic.Targets.Count][];
var targetDamageDist = new IReadOnlyList <JsonDamageDist> [log.FightData.Logic.Targets.Count][];
for (int j = 0; j < log.FightData.Logic.Targets.Count; j++)
{
NPC target = log.FightData.Logic.Targets[j];
var graph1SDamageList = new IReadOnlyList <int> [phases.Count];
var graph1SPowerDamageList = new IReadOnlyList <int> [phases.Count];
var graph1SConditionDamageList = new IReadOnlyList <int> [phases.Count];
var graph1SBreakbarDamageList = new IReadOnlyList <double> [phases.Count];
var targetDamageDistList = new IReadOnlyList <JsonDamageDist> [phases.Count];
for (int i = 0; i < phases.Count; i++)
{
PhaseData phase = phases[i];
if (settings.RawFormatTimelineArrays)
{
graph1SDamageList[i] = player.Get1SDamageList(log, phase.Start, phase.End, target, DamageType.All);
graph1SPowerDamageList[i] = player.Get1SDamageList(log, phase.Start, phase.End, target, DamageType.Power);
graph1SConditionDamageList[i] = player.Get1SDamageList(log, phase.Start, phase.End, target, DamageType.Condition);
graph1SBreakbarDamageList[i] = player.Get1SBreakbarDamageList(log, phase.Start, phase.End, target);
}
targetDamageDistList[i] = JsonDamageDist.BuildJsonDamageDistList(player.GetDamageEvents(target, log, phase.Start, phase.End).GroupBy(x => x.SkillId).ToDictionary(x => x.Key, x => x.ToList()), log, skillDesc, buffDesc);
}
if (settings.RawFormatTimelineArrays)
{
targetDamage1S[j] = graph1SDamageList;
targetPowerDamage1S[j] = graph1SPowerDamageList;
targetConditionDamage1S[j] = graph1SConditionDamageList;
targetBreakbarDamage1S[j] = graph1SBreakbarDamageList;
}
targetDamageDist[j] = targetDamageDistList;
dpsTargets[j] = phases.Select(phase => new JsonStatistics.JsonDPS(player.GetDPSStats(target, log, phase.Start, phase.End))).ToArray();
statsTargets[j] = phases.Select(phase => new JsonStatistics.JsonGameplayStats(player.GetGameplayStats(target, log, phase.Start, phase.End))).ToArray();
}
if (settings.RawFormatTimelineArrays)
{
TargetDamage1S = targetDamage1S;
TargetPowerDamage1S = targetPowerDamage1S;
TargetConditionDamage1S = targetConditionDamage1S;
TargetBreakbarDamage1S = targetBreakbarDamage1S;
}
TargetDamageDist = targetDamageDist;
DpsTargets = dpsTargets;
StatsTargets = statsTargets;
if (!log.CombatData.HasBreakbarDamageData)
{
TargetBreakbarDamage1S = null;
}
//
BuffUptimes = GetPlayerJsonBuffsUptime(player, phases.Select(phase => player.GetBuffs(BuffEnum.Self, log, phase.Start, phase.End)).ToList(), log, settings, buffDesc, personalBuffs);
SelfBuffs = GetPlayerBuffGenerations(phases.Select(phase => player.GetBuffs(BuffEnum.Self, log, phase.Start, phase.End)).ToList(), log, buffDesc);
GroupBuffs = GetPlayerBuffGenerations(phases.Select(phase => player.GetBuffs(BuffEnum.Group, log, phase.Start, phase.End)).ToList(), log, buffDesc);
OffGroupBuffs = GetPlayerBuffGenerations(phases.Select(phase => player.GetBuffs(BuffEnum.OffGroup, log, phase.Start, phase.End)).ToList(), log, buffDesc);
SquadBuffs = GetPlayerBuffGenerations(phases.Select(phase => player.GetBuffs(BuffEnum.Squad, log, phase.Start, phase.End)).ToList(), log, buffDesc);
//
BuffUptimesActive = GetPlayerJsonBuffsUptime(player, phases.Select(phase => player.GetActiveBuffs(BuffEnum.Self, log, phase.Start, phase.End)).ToList(), log, settings, buffDesc, personalBuffs);
SelfBuffsActive = GetPlayerBuffGenerations(phases.Select(phase => player.GetActiveBuffs(BuffEnum.Self, log, phase.Start, phase.End)).ToList(), log, buffDesc);
GroupBuffsActive = GetPlayerBuffGenerations(phases.Select(phase => player.GetActiveBuffs(BuffEnum.Group, log, phase.Start, phase.End)).ToList(), log, buffDesc);
OffGroupBuffsActive = GetPlayerBuffGenerations(phases.Select(phase => player.GetActiveBuffs(BuffEnum.OffGroup, log, phase.Start, phase.End)).ToList(), log, buffDesc);
SquadBuffsActive = GetPlayerBuffGenerations(phases.Select(phase => player.GetActiveBuffs(BuffEnum.Squad, log, phase.Start, phase.End)).ToList(), log, buffDesc);
//
IReadOnlyList <Consumable> consumables = player.GetConsumablesList(log, 0, log.FightData.FightEnd);
if (consumables.Any())
{
var consumablesJSON = new List <JsonConsumable>();
foreach (Consumable food in consumables)
{
if (!buffDesc.ContainsKey("b" + food.Buff.ID))
{
buffDesc["b" + food.Buff.ID] = new JsonLog.BuffDesc(food.Buff, log);
}
consumablesJSON.Add(new JsonConsumable(food));
}
Consumables = consumablesJSON;
}
//
IReadOnlyList <DeathRecap> deathRecaps = player.GetDeathRecaps(log);
if (deathRecaps.Any())
{
DeathRecap = deathRecaps.Select(x => new JsonDeathRecap(x)).ToList();
}
//
DamageModifiers = JsonDamageModifierData.GetDamageModifiers(player.GetDamageModifierStats(log, null), log, damageModDesc);
DamageModifiersTarget = JsonDamageModifierData.GetDamageModifiersTarget(player, log, damageModDesc);
}
private void CalculateConditions()
{
foreach (Target target in _log.FightData.Logic.Targets)
{
Dictionary <long, FinalTargetBuffs>[] stats = new Dictionary <long, FinalTargetBuffs> [_statistics.Phases.Count];
for (int phaseIndex = 0; phaseIndex < _statistics.Phases.Count; phaseIndex++)
{
BoonDistribution boonDistribution = target.GetBoonDistribution(_log, phaseIndex);
Dictionary <long, FinalTargetBuffs> rates = new Dictionary <long, FinalTargetBuffs>();
Dictionary <long, long> boonPresence = target.GetBoonPresence(_log, phaseIndex);
Dictionary <long, long> condiPresence = target.GetCondiPresence(_log, phaseIndex);
PhaseData phase = _statistics.Phases[phaseIndex];
long fightDuration = phase.GetDuration();
foreach (Boon boon in target.TrackedBoons)
{
if (boonDistribution.ContainsKey(boon.ID))
{
FinalTargetBuffs buff = new FinalTargetBuffs(_log.PlayerList);
rates[boon.ID] = buff;
if (boon.Type == Boon.BoonType.Duration)
{
buff.Uptime = Math.Round(100.0 * boonDistribution.GetUptime(boon.ID) / fightDuration, 2);
foreach (Player p in _log.PlayerList)
{
long gen = boonDistribution.GetGeneration(boon.ID, p.AgentItem);
buff.Generated[p] = Math.Round(100.0 * gen / fightDuration, 2);
buff.Overstacked[p] = Math.Round(100.0 * (boonDistribution.GetOverstack(boon.ID, p.AgentItem) + gen) / fightDuration, 2);
buff.Wasted[p] = Math.Round(100.0 * boonDistribution.GetWaste(boon.ID, p.AgentItem) / fightDuration, 2);
buff.UnknownExtension[p] = Math.Round(100.0 * boonDistribution.GetUnknownExtension(boon.ID, p.AgentItem) / fightDuration, 2);
buff.Extension[p] = Math.Round(100.0 * boonDistribution.GetExtension(boon.ID, p.AgentItem) / fightDuration, 2);
buff.Extended[p] = Math.Round(100.0 * boonDistribution.GetExtended(boon.ID, p.AgentItem) / fightDuration, 2);
}
}
else if (boon.Type == Boon.BoonType.Intensity)
{
buff.Uptime = Math.Round((double)boonDistribution.GetUptime(boon.ID) / fightDuration, 2);
foreach (Player p in _log.PlayerList)
{
long gen = boonDistribution.GetGeneration(boon.ID, p.AgentItem);
buff.Generated[p] = Math.Round((double)gen / fightDuration, 2);
buff.Overstacked[p] = Math.Round((double)(boonDistribution.GetOverstack(boon.ID, p.AgentItem) + gen) / fightDuration, 2);
buff.Wasted[p] = Math.Round((double)boonDistribution.GetWaste(boon.ID, p.AgentItem) / fightDuration, 2);
buff.UnknownExtension[p] = Math.Round((double)boonDistribution.GetUnknownExtension(boon.ID, p.AgentItem) / fightDuration, 2);
buff.Extension[p] = Math.Round((double)boonDistribution.GetExtension(boon.ID, p.AgentItem) / fightDuration, 2);
buff.Extended[p] = Math.Round((double)boonDistribution.GetExtended(boon.ID, p.AgentItem) / fightDuration, 2);
}
if (boonPresence.TryGetValue(boon.ID, out long presenceValueBoon))
{
buff.Presence = Math.Round(100.0 * presenceValueBoon / fightDuration, 2);
}
else if (condiPresence.TryGetValue(boon.ID, out long presenceValueCondi))
{
buff.Presence = Math.Round(100.0 * presenceValueCondi / fightDuration, 2);
}
}
}
}
stats[phaseIndex] = rates;
}
_statistics.TargetBuffs[target] = stats;
}
}
