public void CreateXML()
{
var log = new JsonLog();
SetGeneral(log);
SetTargets(log);
SetPlayers(log);
SetPhases(log);
SetMechanics(log);
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
JsonSerializerSettings settings = new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = contractResolver
};
Dictionary <string, JsonLog> root = new Dictionary <string, JsonLog>()
{
{ "log", log }
};
string json = JsonConvert.SerializeObject(root, settings);
XmlDocument xml = JsonConvert.DeserializeXmlNode(json);
XmlTextWriter xmlTextWriter = new XmlTextWriter(_sw)
{
Formatting = Properties.Settings.Default.IndentXML ? System.Xml.Formatting.Indented : System.Xml.Formatting.None
};
xml.WriteTo(xmlTextWriter);
}
private void SetPhases(JsonLog log)
{
log.Phases = new List <JsonPhase>();
foreach (var phase in _statistics.Phases)
{
JsonPhase phaseJson = new JsonPhase
{
Start = phase.Start,
End = phase.End,
Name = phase.Name
};
if (_devMode)
{
phaseJson.ED = new JsonPhase.JsonExtraPhase
{
TI = new int[phase.Targets.Count],
DA = phase.DrawArea ? 1 : 0,
DE = phase.DrawEnd ? 1 : 0,
DS = phase.DrawStart ? 1 : 0
};
int i = 0;
foreach (Boss target in phase.Targets)
{
phaseJson.ED.TI[i++] = _log.FightData.Logic.Targets.IndexOf(target);
}
}
log.Phases.Add(phaseJson);
}
}
private void SetPhases(JsonLog log)
{
log.Phases = new List <JsonPhase>();
foreach (var phase in _statistics.Phases)
{
JsonPhase phaseJson = new JsonPhase(phase);
foreach (Target tar in phase.Targets)
{
phaseJson.Targets.Add(_log.FightData.Logic.Targets.IndexOf(tar));
}
log.Phases.Add(phaseJson);
for (int j = 1; j < _statistics.Phases.Count; j++)
{
PhaseData curPhase = _statistics.Phases[j];
if (curPhase.Start < phaseJson.Start || curPhase.End > phaseJson.End ||
(curPhase.Start == phaseJson.Start && curPhase.End == phaseJson.End))
{
continue;
}
if (phaseJson.SubPhases == null)
{
phaseJson.SubPhases = new List <int>();
}
phaseJson.SubPhases.Add(j);
}
}
}
private void SetBoss(JsonLog log)
{
log.Boss = new List <JsonBoss>();
foreach (Boss target in _log.FightData.Logic.Targets)
{
JsonBoss boss = new JsonBoss();
boss.Id = target.ID;
boss.Name = target.Character;
boss.TotalHealth = target.Health;
int finalBossHealth = target.HealthOverTime.Count > 0
? target.HealthOverTime.Last().Y
: 10000;
boss.FinalHealth = target.Health * (finalBossHealth * 0.01);
boss.HealthPercentBurned = 100.0 - finalBossHealth * 0.01;
boss.AvgBoons = _statistics.AvgBossBoons[target];
boss.AvgConditions = _statistics.AvgBossConditions[target];
boss.Dps = BuildDPS(_statistics.BossDps[target]);
boss.Buffs = BuildBossBuffs(_statistics.BossConditions[target], target);
boss.HitboxHeight = target.HitboxHeight;
boss.HitboxWidth = target.HitboxWidth;
boss.Dps1s = Build1SDPS(target, null);
boss.Rotation = BuildRotation(target.GetCastLogs(_log, 0, _log.FightData.FightDuration));
boss.FirstAware = (int)(target.FirstAware - _log.FightData.FightStart);
boss.LastAware = (int)(target.LastAware - _log.FightData.FightStart);
boss.Minions = BuildMinions(target);
boss.TotalDamageDist = BuildDamageDist(target, null);
boss.AvgBoonsStates = BuildBuffStates(target.GetBoonGraphs(_log)[-2]);
boss.AvgConditionsStates = BuildBuffStates(target.GetBoonGraphs(_log)[-3]);
log.Boss.Add(boss);
if (_devMode)
{
_actorIconData[target.Character] = GeneralHelper.GetNPCIcon(target.ID);
}
}
}
public void CreateJSON()
{
var log = new JsonLog();
SetGeneral(log);
SetTargets(log);
SetPlayers(log);
SetPhases(log);
SetMechanics(log);
DefaultContractResolver contractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
};
var serializer = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = contractResolver
};
var writer = new JsonTextWriter(_sw)
{
Formatting = _settings.IndentJSON ? Newtonsoft.Json.Formatting.Indented : Newtonsoft.Json.Formatting.None
};
serializer.Serialize(writer, log);
}
private void SetGeneral(JsonLog log)
{
double fightDuration = _log.FightData.FightDuration / 1000.0;
var duration = TimeSpan.FromSeconds(fightDuration);
string durationString = duration.ToString("mm") + "m " + duration.ToString("ss") + "s";
if (duration.ToString("hh") != "00")
{
durationString = duration.ToString("hh") + "h " + durationString;
}
log.TriggerID = _log.FightData.ID;
log.FightName = _log.FightData.Name;
log.EliteInsightsVersion = Program.Version;
log.ArcVersion = _log.LogData.BuildVersion;
log.RecordedBy = _log.LogData.PoV.Split(':')[0].TrimEnd('\u0000');
log.TimeStart = _log.LogData.LogStart;
log.TimeEnd = _log.LogData.LogEnd;
log.Duration = durationString;
log.Success = _log.FightData.Success;
log.SkillMap = _skillDesc;
log.BuffMap = _buffDesc;
log.DamageModMap = _damageModDesc;
log.PersonalBuffs = _personalBuffs;
log.UploadLinks = _uploadLink;
}
//
public RawFormatBuilder(ParsedEvtcLog log, RawFormatSettings settings, string[] uploadLinks = null)
{
if (settings == null)
{
throw new InvalidDataException("Missing settings in RawFormatBuilder");
}
JsonLog = new JsonLog(log, settings, uploadLinks);
}
//
public RawFormatBuilder(ParsedEvtcLog log, RawFormatSettings settings, Version parserVersion, UploadResults uploadResults)
{
if (settings == null)
{
throw new InvalidDataException("Missing settings in RawFormatBuilder");
}
_jsonLog = JsonLogBuilder.BuildJsonLog(log, settings, parserVersion, uploadResults.ToArray());
}
public JsonLog CreateJsonLog()
{
var log = new JsonLog();
SetGeneral(log);
SetTargets(log);
SetPlayers(log);
SetPhases(log);
SetMechanics(log);
return(log);
}
private void SetPlayers(JsonLog log)
{
log.Players = new List <JsonPlayer>();
foreach (var player in _log.PlayerList)
{
log.Players.Add(new JsonPlayer
{
Name = player.Character,
Account = player.Account,
Condition = player.Condition,
Concentration = player.Concentration,
Healing = player.Healing,
Toughness = player.Toughness,
HitboxHeight = player.HitboxHeight,
HitboxWidth = player.HitboxWidth,
Weapons = player.GetWeaponsArray(_log).Select(w => w ?? "Unknown").ToArray(),
Group = player.Group,
Profession = player.Prof,
Damage1S = BuildTotal1SDamage(player),
TargetDamage1S = BuildTarget1SDamage(player),
DpsAll = player.GetDPSAll(_log).Select(x => new JsonDPS(x)).ToArray(),
DpsTargets = BuildDPSTarget(player),
StatsAll = player.GetStatsAll(_log).Select(x => new JsonStatsAll(x)).ToArray(),
StatsTargets = BuildStatsTarget(player),
Defenses = player.GetDefenses(_log).Select(x => new JsonDefenses(x)).ToArray(),
Rotation = BuildRotation(player.GetCastLogs(_log, 0, _log.FightData.FightDuration)),
Support = player.GetSupport(_log).Select(x => new JsonSupport(x)).ToArray(),
BuffUptimes = BuildPlayerBuffUptimes(player.GetBuffs(_log, Statistics.BuffEnum.Self), player),
SelfBuffs = BuildPlayerBuffGenerations(player.GetBuffs(_log, Statistics.BuffEnum.Self)),
GroupBuffs = BuildPlayerBuffGenerations(player.GetBuffs(_log, Statistics.BuffEnum.Group)),
OffGroupBuffs = BuildPlayerBuffGenerations(player.GetBuffs(_log, Statistics.BuffEnum.OffGroup)),
SquadBuffs = BuildPlayerBuffGenerations(player.GetBuffs(_log, Statistics.BuffEnum.Squad)),
BuffUptimesActive = BuildPlayerBuffUptimes(player.GetActiveBuffs(_log, Statistics.BuffEnum.Self), player),
SelfBuffsActive = BuildPlayerBuffGenerations(player.GetActiveBuffs(_log, Statistics.BuffEnum.Self)),
GroupBuffsActive = BuildPlayerBuffGenerations(player.GetActiveBuffs(_log, Statistics.BuffEnum.Group)),
OffGroupBuffsActive = BuildPlayerBuffGenerations(player.GetActiveBuffs(_log, Statistics.BuffEnum.OffGroup)),
SquadBuffsActive = BuildPlayerBuffGenerations(player.GetActiveBuffs(_log, Statistics.BuffEnum.Squad)),
DamageModifiers = BuildDamageModifiers(player.GetDamageModifierData(_log, null)),
DamageModifiersTarget = BuildDamageModifiersTarget(player),
Minions = BuildMinions(player),
TotalDamageDist = BuildDamageDist(player, null),
TargetDamageDist = BuildDamageDist(player),
TotalDamageTaken = BuildDamageTaken(player),
DeathRecap = BuildDeathRecap(player.GetDeathRecaps(_log)),
Consumables = BuildConsumables(player),
BoonsStates = BuildBuffStates(player.GetBoonGraphs(_log)[ProfHelper.NumberOfBoonsID]),
ConditionsStates = BuildBuffStates(player.GetBoonGraphs(_log)[ProfHelper.NumberOfConditionsID]),
ActiveTimes = _phases.Select(x => x.GetPlayerActiveDuration(player, _log)).ToList(),
});
}
}
private void SetTargets(JsonLog log)
{
log.Targets = new List <JsonTarget>();
foreach (Target target in _log.FightData.Logic.Targets)
{
JsonTarget jsTarget = new JsonTarget
{
Id = target.ID,
Name = target.Character,
Toughness = target.Toughness,
Healing = target.Healing,
Concentration = target.Concentration,
Condition = target.Condition,
TotalHealth = target.GetHealth(_log.CombatData),
AvgBoons = target.GetAverageBoons(_log),
AvgConditions = target.GetAverageConditions(_log),
DpsAll = target.GetDPSAll(_log).Select(x => new JsonDPS(x)).ToArray(),
Buffs = BuildTargetBuffs(target.GetBuffs(_log), target),
HitboxHeight = target.HitboxHeight,
HitboxWidth = target.HitboxWidth,
Damage1S = BuildTotal1SDamage(target),
Rotation = BuildRotation(target.GetCastLogs(_log, 0, _log.FightData.FightDuration)),
FirstAware = (int)(_log.FightData.ToFightSpace(target.FirstAwareLogTime)),
LastAware = (int)(_log.FightData.ToFightSpace(target.LastAwareLogTime)),
Minions = BuildMinions(target),
TotalDamageDist = BuildDamageDist(target, null),
TotalDamageTaken = BuildDamageTaken(target),
BoonsStates = BuildBuffStates(target.GetBoonGraphs(_log)[ProfHelper.NumberOfBoonsID]),
ConditionsStates = BuildBuffStates(target.GetBoonGraphs(_log)[ProfHelper.NumberOfConditionsID]),
HealthPercents = _log.CombatData.GetHealthUpdateEvents(target.AgentItem).Select(x => new double[2] {
x.Time, x.HPPercent
}).ToList()
};
double hpLeft = 0.0;
if (_log.FightData.Success)
{
hpLeft = 0;
}
else
{
List <HealthUpdateEvent> hpUpdates = _log.CombatData.GetHealthUpdateEvents(target.AgentItem);
if (hpUpdates.Count > 0)
{
hpLeft = hpUpdates.Last().HPPercent;
}
}
jsTarget.HealthPercentBurned = 100.0 - hpLeft;
jsTarget.FinalHealth = (int)Math.Round(target.GetHealth(_log.CombatData) * hpLeft / 100.0);
log.Targets.Add(jsTarget);
}
}
private void SetPhases(JsonLog log)
{
log.phases = new List <JsonPhase>();
foreach (var phase in _statistics.Phases)
{
JsonPhase phaseJson = new JsonPhase
{
start = phase.Start,
end = phase.End,
name = phase.Name
};
log.phases.Add(phaseJson);
}
}
/// <summary>
/// Creates a json file based on the given JsonLog
/// </summary>
/// <param name="jsonLog"></param>
/// <param name="sw"></param>
/// <param name="indent"></param>
public static void CreateJSON(JsonLog jsonLog, StreamWriter sw, bool indent)
{
var serializer = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = DefaultJsonContractResolver
};
var writer = new JsonTextWriter(sw)
{
Formatting = indent ? Newtonsoft.Json.Formatting.Indented : Newtonsoft.Json.Formatting.None
};
serializer.Serialize(writer, jsonLog);
writer.Close();
}
private void SetPlayers(JsonLog log)
{
log.Players = new List <JsonPlayer>();
foreach (var player in _log.PlayerList)
{
log.Players.Add(new JsonPlayer
{
Name = player.Character,
Account = player.Account,
Condition = player.Condition,
Concentration = player.Concentration,
Healing = player.Healing,
Toughness = player.Toughness,
HitboxHeight = player.HitboxHeight,
HitboxWidth = player.HitboxWidth,
Weapons = player.GetWeaponsArray(_log).Where(w => w != null).ToArray(),
Group = player.Group,
Profession = player.Prof,
Damage1S = BuildTotal1SDamage(player),
TargetDamage1S = BuildTarget1SDamage(player),
DpsAll = _statistics.DpsAll[player].Select(x => new JsonDPS(x)).ToArray(),
DpsTargets = BuildDPSTarget(_statistics.DpsTarget, player),
StatsAll = _statistics.StatsAll[player].Select(x => new JsonStatsAll(x)).ToArray(),
StatsTargets = BuildStatsTarget(_statistics.StatsTarget, player),
Defenses = _statistics.Defenses[player].Select(x => new JsonDefenses(x)).ToArray(),
Rotation = BuildRotation(player.GetCastLogs(_log, 0, _log.FightData.FightDuration)),
Support = _statistics.Support[player].Select(x => new JsonSupport(x)).ToArray(),
BuffUptimes = BuildPlayerBuffUptimes(_statistics.SelfBuffs[player], player),
SelfBuffs = BuildPlayerBuffGenerations(_statistics.SelfBuffs[player], player),
GroupBuffs = BuildPlayerBuffGenerations(_statistics.GroupBuffs[player], player),
OffGroupBuffs = BuildPlayerBuffGenerations(_statistics.OffGroupBuffs[player], player),
SquadBuffs = BuildPlayerBuffGenerations(_statistics.SquadBuffs[player], player),
DamageModifiers = BuildDamageModifiers(player.GetExtraBoonData(_log, null)),
DamageModifiersTarget = BuildDamageModifiersTarget(player),
Minions = BuildMinions(player),
TotalDamageDist = BuildDamageDist(player, null),
TargetDamageDist = BuildDamageDist(player),
TotalDamageTaken = BuildDamageTaken(player),
DeathRecap = BuildDeathRecap(player.GetDeathRecaps(_log)),
Consumables = BuildConsumables(player),
BoonsStates = BuildBuffStates(player.GetBoonGraphs(_log)[Boon.NumberOfBoonsID]),
ConditionsStates = BuildBuffStates(player.GetBoonGraphs(_log)[Boon.NumberOfConditionsID]),
});
}
}
private void SetPlayers(JsonLog log)
{
log.Players = new List <JsonPlayer>();
foreach (var player in _log.PlayerList)
{
log.Players.Add(new JsonPlayer
{
Character = player.Character,
Account = player.Account,
Condition = player.Condition,
Concentration = player.Concentration,
Healing = player.Healing,
Toughness = player.Toughness,
Weapons = player.GetWeaponsArray(_log).Where(w => w != null).ToArray(),
Group = player.Group,
Profession = player.Prof,
Dps1s = Build1SDPS(player, null),
TargetDps1s = Build1SDPS(player),
DpsAll = BuildDPS(_statistics.DpsAll[player]),
DpsBoss = BuildDPSBoss(_statistics.DpsBoss, player),
StatsAll = BuildStatsAll(_statistics.StatsAll[player]),
StatsBoss = BuildStatsBoss(_statistics.StatsBoss, player),
Defenses = BuildDefenses(_statistics.Defenses[player]),
Rotation = BuildRotation(player.GetCastLogs(_log, 0, _log.FightData.FightDuration)),
Support = BuildSupport(_statistics.Support[player]),
SelfBuffs = BuildBuffUptime(_statistics.SelfBoons[player], player),
GroupBuffs = BuildBuffUptime(_statistics.GroupBoons[player], player),
OffGroupBuffs = BuildBuffUptime(_statistics.OffGroupBoons[player], player),
SquadBuffs = BuildBuffUptime(_statistics.SquadBoons[player], player),
Minions = BuildMinions(player),
TotalDamageDist = BuildDamageDist(player, null),
TargetDamageDist = BuildDamageDist(player),
TotalDamageTaken = BuildDamageTaken(player),
DeathRecap = BuilDeathRecap(player),
Consumables = BuildConsumables(player),
AvgBoonsStates = BuildBuffStates(player.GetBoonGraphs(_log)[Boon.NumberOfBoonsID]),
AvgConditionsStates = BuildBuffStates(player.GetBoonGraphs(_log)[Boon.NumberOfConditionsID]),
});
if (_devMode)
{
_actorIconData[player.Prof] = GeneralHelper.GetProfIcon(player.Prof);
}
}
}
private void SetGeneral(JsonLog log)
{
log.TriggerID = _log.FightData.ID;
log.FightName = _log.FightData.Name;
log.FightIcon = _log.FightData.Logic.IconUrl;
log.EliteInsightsVersion = Application.ProductVersion;
log.ArcVersion = _log.LogData.BuildVersion;
log.RecordedBy = _log.LogData.PoVName;
log.TimeStart = _log.LogData.LogStart;
log.TimeEnd = _log.LogData.LogEnd;
log.Duration = _log.FightData.DurationString;
log.Success = _log.FightData.Success;
log.SkillMap = _skillDesc;
log.BuffMap = _buffDesc;
log.DamageModMap = _damageModDesc;
log.PersonalBuffs = _personalBuffs;
log.UploadLinks = _uploadLink;
}
private void SetMechanics(JsonLog log)
{
MechanicData mechanicData = _log.MechanicData;
var mechanicLogs = new List <MechanicLog>();
foreach (var mLog in mechanicData.Values)
{
mechanicLogs.AddRange(mLog);
}
if (mechanicLogs.Any())
{
log.Mechanics = new List <JsonMechanics>();
Dictionary <string, List <JsonMechanic> > dict = new Dictionary <string, List <JsonMechanic> >();
foreach (MechanicLog ml in mechanicLogs)
{
JsonMechanic mech = new JsonMechanic
{
Time = ml.Time,
Actor = ml.Actor.Character
};
if (dict.TryGetValue(ml.InGameName, out var list))
{
list.Add(mech);
}
else
{
dict[ml.InGameName] = new List <JsonMechanic>()
{
mech
};
}
}
foreach (var pair in dict)
{
log.Mechanics.Add(new JsonMechanics()
{
Name = pair.Key,
MechanicsData = pair.Value
});
}
}
}
private void SetPlayers(JsonLog log)
{
log.players = new List <JsonPlayer>();
foreach (var player in _log.PlayerList)
{
log.players.Add(new JsonPlayer
{
character = player.Character,
account = player.Account,
condition = player.Condition,
concentration = player.Concentration,
healing = player.Healing,
toughness = player.Toughness,
weapons = player.GetWeaponsArray(_log).Where(w => w != null).ToArray(),
group = player.Group,
profession = player.Prof,
damage1S = BuildTotal1SDamage(player),
targetDamage1S = BuildTarget1SDamage(player),
dpsAll = BuildDPS(_statistics.DpsAll[player]),
dpsTargets = BuildDPSTarget(_statistics.DpsTarget, player),
statsAll = BuildStatsAll(_statistics.StatsAll[player]),
statsTargets = BuildStatsTarget(_statistics.StatsTarget, player),
defenses = BuildDefenses(_statistics.Defenses[player]),
totation = BuildRotation(player.GetCastLogs(_log, 0, _log.FightData.FightDuration)),
support = BuildSupport(_statistics.Support[player]),
selfBuffs = BuildBuffUptime(_statistics.SelfBuffs[player], player),
groupBuffs = BuildBuffUptime(_statistics.GroupBuffs[player], player),
offGroupBuffs = BuildBuffUptime(_statistics.OffGroupBuffs[player], player),
squadBuffs = BuildBuffUptime(_statistics.SquadBuffs[player], player),
minions = BuildMinions(player),
totalDamageDist = BuildDamageDist(player, null),
targetDamageDist = BuildDamageDist(player),
totalDamageTaken = BuildDamageTaken(player),
deathRecap = BuildDeathRecaps(player),
consumables = BuildConsumables(player),
avgBoonsStates = BuildBuffStates(player.GetBoonGraphs(_log)[Boon.NumberOfBoonsID]),
avgConditionsStates = BuildBuffStates(player.GetBoonGraphs(_log)[Boon.NumberOfConditionsID]),
});
}
}
/// <summary>
/// Returns a copy of JsonLog object that will be used by the builder.
/// </summary>
/// <returns></returns>
public JsonLog GetJson()
{
var sw = new StringWriter();
var serializer = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore
};
var writer = new JsonTextWriter(sw)
{
Formatting = Newtonsoft.Json.Formatting.None
};
serializer.Serialize(writer, _jsonLog);
writer.Close();
JsonLog log = JsonConvert.DeserializeObject <JsonLog>(sw.ToString(), new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
return(log);
}
public void CreateJSON()
{
var log = new JsonLog();
SetGeneral(log);
SetTargets(log);
SetPlayers(log);
SetPhases(log);
SetMechanics(log);
var serializer = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore
};
var writer = new JsonTextWriter(_sw)
{
Formatting = _settings.IndentJSON ? Newtonsoft.Json.Formatting.Indented : Newtonsoft.Json.Formatting.None
};
serializer.Serialize(writer, log);
}
/// <summary>
/// Creates an xml file based on the given JsonLog
/// </summary>
/// <param name="jsonLog"></param>
/// <param name="sw"></param>
/// <param name="indent"></param>
public static void CreateXML(JsonLog jsonLog, StreamWriter sw, bool indent)
{
var settings = new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = DefaultJsonContractResolver
};
var root = new Dictionary <string, JsonLog>()
{
{ "log", jsonLog }
};
string json = JsonConvert.SerializeObject(root, settings);
XmlDocument xml = JsonConvert.DeserializeXmlNode(json);
var xmlTextWriter = new XmlTextWriter(sw)
{
Formatting = indent ? System.Xml.Formatting.Indented : System.Xml.Formatting.None
};
xml.WriteTo(xmlTextWriter);
xmlTextWriter.Close();
}
private void SetGeneral(JsonLog log)
{
double fightDuration = _log.FightData.FightDuration / 1000.0;
var duration = TimeSpan.FromSeconds(fightDuration);
string durationString = duration.ToString("mm") + "m " + duration.ToString("ss") + "s";
if (duration.ToString("hh") != "00")
{
durationString = duration.ToString("hh") + "h " + durationString;
}
log.TriggerID = _log.FightData.ID;
log.FightName = _log.FightData.Name;
log.EliteInsightsVersion = Application.ProductVersion;
log.ArcVersion = _log.LogData.BuildVersion;
log.RecordedBy = _log.LogData.PoV.Split(':')[0].TrimEnd('\u0000');
log.TimeStart = _log.LogData.LogStart;
log.TimeEnd = _log.LogData.LogEnd;
log.Duration = durationString;
log.Success = _log.LogData.Success ? 1 : 0;
log.SkillNames = _skillNames;
log.BuffNames = _buffNames;
if (!_devMode)
{
log.UploadLinks = _uploadLink;
}
else
{
log.ED = new JsonExtraLog()
{
BuffData = _buffData,
SkillIcons = _skillIcons,
FightIcon = _log.FightData.Logic.IconUrl,
MechanicData = _mechanicData,
ActorIcons = _actorIconData,
PersonalBuffs = _personalBuffs,
};
}
}
private void SetTargets(JsonLog log)
{
log.Targets = new List <JsonTarget>();
foreach (Target target in _log.FightData.Logic.Targets)
{
JsonTarget jsTarget = new JsonTarget
{
Id = target.ID,
Name = target.Character,
Toughness = target.Toughness,
Healing = target.Healing,
Concentration = target.Concentration,
Condition = target.Condition,
TotalHealth = target.Health,
AvgBoons = target.GetAverageBoons(_log),
AvgConditions = target.GetAverageConditions(_log),
DpsAll = target.GetDPSAll(_log).Select(x => new JsonDPS(x)).ToArray(),
Buffs = BuildTargetBuffs(target.GetBuffs(_log), target),
HitboxHeight = target.HitboxHeight,
HitboxWidth = target.HitboxWidth,
Damage1S = BuildTotal1SDamage(target),
Rotation = BuildRotation(target.GetCastLogs(_log, 0, _log.FightData.FightDuration)),
FirstAware = (int)(_log.FightData.ToFightSpace(target.FirstAware)),
LastAware = (int)(_log.FightData.ToFightSpace(target.LastAware)),
Minions = BuildMinions(target),
TotalDamageDist = BuildDamageDist(target, null),
TotalDamageTaken = BuildDamageTaken(target),
BoonsStates = BuildBuffStates(target.GetBoonGraphs(_log)[Boon.NumberOfBoonsID]),
ConditionsStates = BuildBuffStates(target.GetBoonGraphs(_log)[Boon.NumberOfConditionsID])
};
int finalTargetHealth = target.HealthOverTime.Count > 0
? target.HealthOverTime.Last().hp
: 10000;
jsTarget.FinalHealth = (int)Math.Round(target.Health * (finalTargetHealth * 0.01));
jsTarget.HealthPercentBurned = 100.0 - finalTargetHealth * 0.01;
log.Targets.Add(jsTarget);
}
}
private void SetGeneral(JsonLog log)
{
double fightDuration = _log.FightData.FightDuration / 1000.0;
var duration = TimeSpan.FromSeconds(fightDuration);
string durationString = duration.ToString("mm") + "m " + duration.ToString("ss") + "s";
if (duration.ToString("hh") != "00")
{
durationString = duration.ToString("hh") + "h " + durationString;
}
log.triggerID = _log.FightData.ID;
log.fightName = _log.FightData.Name;
log.eliteInsightsVersion = Application.ProductVersion;
log.arcVersion = _log.LogData.BuildVersion;
log.recordedBy = _log.LogData.PoV.Split(':')[0].TrimEnd('\u0000');
log.timeStart = _log.LogData.LogStart;
log.timeEnd = _log.LogData.LogEnd;
log.duration = durationString;
log.success = _log.FightData.Success;
log.skillNames = _skillNames;
log.buffNames = _buffNames;
log.personalBuffs = _personalBuffs;
log.uploadLinks = _uploadLink;
}
private void SetMechanics(JsonLog log)
{
MechanicData mechanicData = _log.MechanicData;
var mechanicLogs = new List <MechanicLog>();
foreach (var mLog in mechanicData.Values)
{
mechanicLogs.AddRange(mLog);
}
if (mechanicLogs.Any())
{
log.Mechanics = new Dictionary <string, List <JsonMechanic> >();
foreach (MechanicLog ml in mechanicLogs)
{
JsonMechanic mech = new JsonMechanic
{
Time = ml.Time,
Player = ml.Player.Character
};
if (_devMode)
{
if (!_mechanicData.ContainsKey(ml.ShortName))
{
_mechanicData[ml.ShortName] = new MechanicDesc()
{
PlotlySymbol = ml.PlotlySymbol,
PlotlyColor = ml.PlotlyColor,
Description = ml.Description,
PlotlyName = ml.PlotlyName,
Enemy = ml.Enemy ? 1 : 0
};
}
mech.ED = new JsonMechanic.JsonExtraMechanic()
{
SN = ml.ShortName,
S = ml.Skill
};
if (ml.Enemy)
{
if (ml.Player.GetType() == typeof(Boss))
{
mech.ED.TI = -1;
}
else
{
mech.ED.TI = _log.FightData.Logic.Targets.IndexOf((Boss)ml.Player);
}
}
else
{
mech.ED.TI = _log.PlayerList.IndexOf((Player)ml.Player);
}
}
if (log.Mechanics.TryGetValue(ml.InGameName, out var list))
{
list.Add(mech);
}
else
{
log.Mechanics[ml.InGameName] = new List <JsonMechanic>()
{
mech
};
}
}
}
}
//
public RawFormatBuilder(ParsedLog log, string[] uploadLinks)
{
JsonLog = new JsonLog(log, uploadLinks);
}
//
public RawFormatBuilder(ParsedLog log, string[] uploadLinks, OperationController operation)
{
JsonLog = new JsonLog(log, uploadLinks, operation);
}
