public ParsedLog(LogData logData, FightData fightData, AgentData agentData, SkillData skillData,
CombatData combatData, List <Player> playerList, Target target)
{
_container = new ParsedEvtcContainer(logData, fightData, agentData, skillData, combatData, playerList);
//
FightData.SetSuccess(_container);
if (FightData.FightDuration <= 2200)
{
throw new TooShortException();
}
if (Properties.Settings.Default.SkipFailedTries && !FightData.Success)
{
throw new SkipException();
}
CombatData.Update(FightData.FightEnd);
FightData.SetCM(_container);
//
Boons = new BoonsContainer(logData.GW2Version);
BoonSourceFinder = Boon.GetBoonSourceFinder(logData.GW2Version, Boons);
DamageModifiers = new DamageModifiersContainer(logData.GW2Version);
MechanicData = new MechanicData(fightData);
FightData.Logic.ComputeMechanics(this);
Statistics = new Statistics(this);
LegacyTarget = target;
}
public ParsedLog(LogData logData, FightData fightData, AgentData agentData, SkillData skillData,
CombatData combatData, List <Player> playerList, Target target)
{
LogData = logData;
FightData = fightData;
AgentData = agentData;
SkillData = skillData;
CombatData = combatData;
PlayerList = playerList;
LegacyTarget = target;
MechanicData = new MechanicData(fightData);
PlayerListBySpec = playerList.GroupBy(x => x.Prof).ToDictionary(x => x.Key, x => x.ToList());
PlayerIDs = new HashSet <ushort>(playerList.Select(x => x.InstID));
FightData.SetSuccess(this);
FightData.SetCM(this);
CombatData.Update(FightData.FightEnd);
if (FightData.FightDuration <= 2200)
{
throw new TooShortException();
}
if (Properties.Settings.Default.SkipFailedTries && !FightData.Success)
{
throw new SkipException();
}
}
private MechanicData GetMechanicData()
{
int planetId = Services.PlanetService.CurrentPlanet.Id;
MechanicData mechanicData = Services.ResourceService.MechanicDataRepository.GetMechanicData(planetId);
return(mechanicData);
}
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,
actor = ml.Actor.Character
};
if (log.mechanics.TryGetValue(ml.InGameName, out var list))
{
list.Add(mech);
}
else
{
log.mechanics[ml.InGameName] = new List <JsonMechanic>()
{
mech
};
}
}
}
}
public void Setup(GeneratorInfo generator)
{
this.generator = generator;
this.mechanicData = Services.ResourceService.MechanicDataRepository.GetMechanicData(Services.PlanetService.CurrentPlanet.Id);
UpdateViews();
buyButton.SetListener(() => {
BosError error = Services.TempMechanicService.Buy(generator);
Debug.Log($"Purhase temp mechanic result =>{error}");
if (error == BosError.Ok)
{
Services.SoundService.PlayOneShot(SoundName.buyGenerator);
}
});
adButton.SetListener(() => {
Services.AdService.WatchAd("SpeedUpMechanic", () => {
//Services.TempMechanicService.ApplyAd(generator.GeneratorId);
Services.MechanicService.ForceRepair(generator.GeneratorId, CountToAdRepair());
});
});
adTimer.Setup(.5f, dt => UpdateAdButton(), invokeImmediatly: true);
buyButtonStateTimer.Setup(0.167f, dt => UpdateBuyButtonState());
//adButtonText.text = string.Format(
// Services.ResourceService.Localization.GetString("btn_fmt_speed_up_x_2"),
// "x".Colored("#FDEE21").Size(45),
// "2".Colored("white").Size(54));
SetupTempMechanicsView();
updateTimer.Setup(1, dt => AddMissedMechanics());
SetBuyButtonSprite(true);
}
public BosError BuyMechanic(int generatorId)
{
bool isManagerHired = Services.GetService <IManagerService>().IsHired(generatorId);
if (isManagerHired)
{
int planetId = Services.PlanetService.CurrentPlanet.Id;
MechanicData mechanicData = Services.ResourceService.MechanicDataRepository.GetMechanicData(planetId);
int price = GetNextMechanicPrice(generatorId);
Currency currencyPrice = Currency.CreateCoins(price);
if (Services.PlayerService.IsEnough(currencyPrice))
{
Services.PlayerService.RemoveCurrency(currencyPrice);
AddMechanic(generatorId, 1);
return(BosError.Ok);
}
else
{
return(BosError.NoEnoughCoins);
}
}
else
{
return(BosError.ManagerNotHired);
}
}
public int GetUnitsWhichCanBroke(int generatorId, MechanicData mechanicData, int mechanicCount)
{
int minLiveCount = Services.MechanicService.GetServicedUnitCount(generatorId);
int countToBroke = GetUnitLiveCount(generatorId) - minLiveCount;
if (countToBroke < 0)
{
countToBroke = 0;
}
return(countToBroke);
}
public void ComputeMechanics(ParsedLog log)
{
MechanicData mechData = log.MechanicData;
Dictionary <ushort, DummyActor> regroupedMobs = new Dictionary <ushort, DummyActor>();
foreach (Mechanic mech in MechanicList)
{
mech.CheckMechanic(log, regroupedMobs);
}
mechData.ProcessMechanics(log);
}
public ParsedLog(LogData log_data, BossData boss_data, AgentData agent_data, SkillData skill_data,
CombatData combat_data, MechanicData mech_data, List <Player> p_list, Boss boss)
{
this.log_data = log_data;
this.boss_data = boss_data;
this.agent_data = agent_data;
this.skill_data = skill_data;
this.combat_data = combat_data;
this.mech_data = mech_data;
this.p_list = p_list;
this.boss = boss;
}
public float GetUnitsBrokenedPerHour(MechanicData mechanicData, int unitCountCanBroke)
{
//int countToBroke = GetUnitsWhichCanBroke(generatorId, mechanicData);
if (mechanicData != null && IsLoaded)
{
return(mechanicData.FatigueUntisPercentPerHour * unitCountCanBroke);
}
else
{
return(0f);
}
}
public void ComputeMechanics(ParsedLog log)
{
MechanicData mechData = log.MechanicData;
CombatData combatData = log.CombatData;
HashSet <ushort> playersIds = log.PlayerIDs;
Dictionary <ushort, DummyActor> regroupedMobs = new Dictionary <ushort, DummyActor>();
foreach (Mechanic mech in MechanicList)
{
mech.CheckMechanic(log, regroupedMobs);
}
mechData.ProcessMechanics(log);
}
public ParsedLog(LogData logData, FightData fightData, AgentData agentData, SkillData skillData,
CombatData combatData, List <Player> playerList, Boss boss)
{
LogData = logData;
FightData = fightData;
AgentData = agentData;
SkillData = skillData;
CombatData = combatData;
PlayerList = playerList;
Boss = boss;
MechanicData = new MechanicData(fightData);
PlayerListBySpec = playerList.GroupBy(x => x.Prof).ToDictionary(x => x.Key, x => x.ToList());
FightData.SetSuccess(this);
FightData.SetCM(this);
}
private bool UpdateBroke(float deltaTime)
{
bool isWasBroked = false;
if (IsLoaded && Services.ResourceService.IsLoaded && Services.GameModeService.IsGame)
{
if (MechanicService != null)
{
foreach (var kvp in Units)
{
GeneratorData generatorData = Services.ResourceService.Generators.GetGeneratorData(kvp.Key);
if (generatorData.Type == GeneratorType.Normal)
{
if (Services.ManagerService.IsHired(kvp.Key))
{
MechanicData mechanicData = ResourceService.MechanicDataRepository.GetMechanicData(kvp.Key);
int mechanicCount = MechanicService.GetMechanicCount(kvp.Key);
int unitsWhichCanBrokeCount = GetUnitsWhichCanBroke(kvp.Key, mechanicData, mechanicCount);
if (unitsWhichCanBrokeCount > 0)
{
int minLiveCount = MechanicService.GetServicedUnitCount(generatorData.Id);
int totalUnitCount = GetUnitTotalCount(generatorData.Id);
float speed = GetUnitBrokenSpeed(mechanicData, totalUnitCount);
bool isManagerHired = Services.ManagerService.IsHired(kvp.Key);
bool isBrokeAllowed = Services.MechanicService.IsUnlocked;
if (isManagerHired && isBrokeAllowed)
{
if (kvp.Value.UpdateBroke(deltaTime, speed, minLiveCount, Services))
{
isWasBroked = true;
GameEvents.OnGeneratorUnitsCountChanged(kvp.Value);
}
}
}
}
}
}
}
//UDebug.Log($"was broked => {isWasBroked}");
}
return(isWasBroked);
}
public ParsedLog(LogData logData, FightData fightData, AgentData agentData, SkillData skillData,
CombatData combatData, List <Player> playerList, Target target)
{
LogData = logData;
FightData = fightData;
AgentData = agentData;
SkillData = skillData;
CombatData = combatData;
PlayerList = playerList;
LegacyTarget = target;
MechanicData = new MechanicData(fightData);
PlayerListBySpec = playerList.GroupBy(x => x.Prof).ToDictionary(x => x.Key, x => x.ToList());
FightData.SetSuccess(this);
FightData.SetCM(this);
CombatData.Update(FightData.FightEnd);
}
public JsonLog(ParsedLog log, string[] uploadLinks)
{
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Meta Data");
TriggerID = log.FightData.TriggerID;
FightName = log.FightData.Name;
FightIcon = log.FightData.Logic.Icon;
EliteInsightsVersion = Application.ProductVersion;
ArcVersion = log.LogData.BuildVersion;
RecordedBy = log.LogData.PoVName;
TimeStart = log.LogData.LogStart;
TimeEnd = log.LogData.LogEnd;
TimeStartStd = log.LogData.LogStartStd;
TimeEndStd = log.LogData.LogEndStd;
Duration = log.FightData.DurationString;
Success = log.FightData.Success;
GW2Build = log.LogData.GW2Version;
UploadLinks = uploadLinks;
Language = log.LogData.Language;
LanguageID = (byte)log.LogData.LanguageID;
IsCM = log.FightData.IsCM;
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Mechanics");
MechanicData mechanicData = log.MechanicData;
var mechanicLogs = new List <MechanicEvent>();
foreach (List <MechanicEvent> mLog in mechanicData.GetAllMechanics(log))
{
mechanicLogs.AddRange(mLog);
}
if (mechanicLogs.Any())
{
Mechanics = GetJsonMechanicsList(mechanicLogs);
}
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Phases");
Phases = log.FightData.GetPhases(log).Select(x => new JsonPhase(x, log)).ToList();
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Targets");
Targets = log.FightData.Logic.Targets.Select(x => new JsonNPC(x, log, SkillMap, BuffMap)).ToList();
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Players");
Players = log.PlayerList.Select(x => new JsonPlayer(x, log, SkillMap, BuffMap, DamageModMap, PersonalBuffs)).ToList();
}
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
});
}
}
}
public ParsedLog(string buildVersion, FightData fightData, AgentData agentData, SkillData skillData,
List <CombatItem> combatItems, List <Player> playerList)
{
FightData = fightData;
AgentData = agentData;
SkillData = skillData;
PlayerList = playerList;
//
PlayerListBySpec = playerList.GroupBy(x => x.Prof).ToDictionary(x => x.Key, x => x.ToList());
PlayerAgents = new HashSet <AgentItem>(playerList.Select(x => x.AgentItem));
CombatData = new CombatData(combatItems, FightData, AgentData, SkillData, playerList);
LogData = new LogData(buildVersion, CombatData, combatItems);
//
UpdateFightData();
//
Boons = new BoonsContainer(LogData.GW2Version);
DamageModifiers = new DamageModifiersContainer(LogData.GW2Version);
MechanicData = FightData.Logic.GetMechanicData();
Statistics = new Statistics(CombatData, AgentData, FightData, PlayerList, Boons);
}
private void CreateMechList()
{
MechanicData mData = _log.MechanicData;
var mLogs = new List <MechanicEvent>();
foreach (List <MechanicEvent> mLs in mData.GetAllMechanics(_log))
{
mLogs.AddRange(mLs);
}
mLogs = mLogs.OrderBy(x => x.Time).ToList();
int count = 0;
WriteCell("Time");
foreach (MechanicEvent m in mLogs)
{
WriteCell((m.Time / 1000.0).ToString());
}
NewLine();
count++;
WriteCell("Player");
foreach (MechanicEvent m in mLogs)
{
WriteCell(m.Actor.Character);
}
NewLine();
count++;
WriteCell("Mechanic");
foreach (MechanicEvent m in mLogs)
{
WriteCell("\"" + m.Description + "\"");
}
NewLine();
count++;
while (count < 15)//so each graph has equal spacing
{
NewLine();
count++;
}
}
private void CreateMechList(int phaseIndex)
{
MechanicData mData = _log.MechanicData;
List <MechanicLog> mLogs = new List <MechanicLog>();
foreach (List <MechanicLog> mLs in mData.Values)
{
mLogs.AddRange(mLs);
}
mLogs = mLogs.OrderBy(x => x.Time).ToList();
int count = 0;
WriteCell("Time");
foreach (MechanicLog m in mLogs)
{
WriteCell((m.Time / 1000f).ToString());
}
NewLine();
count++;
WriteCell("Player");
foreach (MechanicLog m in mLogs)
{
WriteCell(m.Player.Character);
}
NewLine();
count++;
WriteCell("Mechanic");
foreach (MechanicLog m in mLogs)
{
WriteCell("\"" + m.Description + "\"");
}
NewLine();
count++;
while (count < 15)//so each graph has equal spacing
{
NewLine();
count++;
}
}
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 static JsonLog BuildJsonLog(ParsedEvtcLog log, RawFormatSettings settings, Version parserVersion, string[] uploadLinks)
{
var jsonLog = new JsonLog();
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Meta Data");
jsonLog.TriggerID = log.FightData.TriggerID;
jsonLog.FightName = log.FightData.FightName;
jsonLog.FightIcon = log.FightData.Logic.Icon;
jsonLog.EliteInsightsVersion = parserVersion.ToString();
jsonLog.ArcVersion = log.LogData.ArcVersion;
jsonLog.RecordedBy = log.LogData.PoVName;
jsonLog.TimeStart = log.LogData.LogStart;
jsonLog.TimeEnd = log.LogData.LogEnd;
jsonLog.TimeStartStd = log.LogData.LogStartStd;
jsonLog.TimeEndStd = log.LogData.LogEndStd;
jsonLog.Duration = log.FightData.DurationString;
jsonLog.Success = log.FightData.Success;
jsonLog.GW2Build = log.LogData.GW2Build;
jsonLog.UploadLinks = uploadLinks;
jsonLog.Language = log.LogData.Language;
jsonLog.LanguageID = (byte)log.LogData.LanguageID;
jsonLog.IsCM = log.FightData.IsCM;
var personalBuffs = new Dictionary <string, HashSet <long> >();
var skillMap = new Dictionary <string, SkillDesc>();
var buffMap = new Dictionary <string, BuffDesc>();
var damageModMap = new Dictionary <string, DamageModDesc>();
if (log.StatisticsHelper.PresentFractalInstabilities.Any())
{
var presentFractalInstabilities = new List <long>();
foreach (Buff fractalInstab in log.StatisticsHelper.PresentFractalInstabilities)
{
presentFractalInstabilities.Add(fractalInstab.ID);
if (!buffMap.ContainsKey("b" + fractalInstab.ID))
{
buffMap["b" + fractalInstab.ID] = BuildBuffDesc(fractalInstab, log);
}
}
jsonLog.PresentFractalInstabilities = presentFractalInstabilities;
}
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Mechanics");
MechanicData mechanicData = log.MechanicData;
var mechanicLogs = new List <MechanicEvent>();
foreach (List <MechanicEvent> mLog in mechanicData.GetAllMechanics(log))
{
mechanicLogs.AddRange(mLog);
}
if (mechanicLogs.Any())
{
jsonLog.Mechanics = JsonMechanicsBuilder.GetJsonMechanicsList(mechanicLogs);
}
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Phases");
jsonLog.Phases = log.FightData.GetNonDummyPhases(log).Select(x => JsonPhaseBuilder.BuildJsonPhase(x, log)).ToList();
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Targets");
jsonLog.Targets = log.FightData.Logic.Targets.Select(x => JsonNPCBuilder.BuildJsonNPC(x, log, settings, skillMap, buffMap)).ToList();
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Players");
jsonLog.Players = log.Friendlies.Select(x => JsonPlayerBuilder.BuildJsonPlayer(x, log, settings, skillMap, buffMap, damageModMap, personalBuffs)).ToList();
//
if (log.LogData.LogErrors.Any())
{
jsonLog.LogErrors = new List <string>(log.LogData.LogErrors);
}
if (log.LogData.UsedExtensions.Any())
{
var usedExtensions = new List <ExtensionDesc>();
foreach (AbstractExtensionHandler extension in log.LogData.UsedExtensions)
{
var set = new HashSet <string>();
if (log.LogData.PoV != null)
{
set.Add(log.FindActor(log.LogData.PoV).Character);
foreach (AgentItem agent in extension.RunningExtension)
{
set.Add(log.FindActor(agent).Character);
}
}
usedExtensions.Add(new ExtensionDesc()
{
Name = extension.Name,
Version = extension.Version,
Signature = extension.Signature,
Revision = extension.Revision,
RunningExtension = set.ToList()
});
}
jsonLog.UsedExtensions = usedExtensions;
}
//
jsonLog.PersonalBuffs = personalBuffs.ToDictionary(x => x.Key, x => (IReadOnlyCollection <long>)x.Value);
jsonLog.SkillMap = skillMap;
jsonLog.BuffMap = buffMap;
jsonLog.DamageModMap = damageModMap;
//
if (log.CanCombatReplay)
{
jsonLog.CombatReplayMetaData = JsonCombatReplayMetaDataBuilder.BuildJsonCombatReplayMetaData(log, settings);
}
return(jsonLog);
}
public float GetUnitBrokenSpeed(MechanicData mechanicData, int unitCountCanBroke)
{
return(GetUnitsBrokenedPerHour(mechanicData, unitCountCanBroke) / 3600.0f);
}
public ParsedLog(LogData logData, FightData fightData, AgentData agentData, SkillData skillData,
CombatData combatData, List <Player> playerList, Target target)
{
LogData = logData;
FightData = fightData;
AgentData = agentData;
SkillData = skillData;
CombatData = combatData;
PlayerList = playerList;
BoonSourceFinder = Boon.GetBoonSourceFinder(logData.GW2Version);
LegacyTarget = target;
MechanicData = new MechanicData(fightData);
PlayerListBySpec = playerList.GroupBy(x => x.Prof).ToDictionary(x => x.Key, x => x.ToList());
PlayerIDs = new HashSet <ushort>(playerList.Select(x => x.InstID));
FightData.SetSuccess(this);
FightData.SetCM(this);
CombatData.Update(FightData.FightEnd);
if (FightData.FightDuration <= 2200)
{
throw new TooShortException();
}
if (Properties.Settings.Default.SkipFailedTries && !FightData.Success)
{
throw new SkipException();
}
// init combat replay
if (Properties.Settings.Default.ParseCombatReplay && FightData.Logic.CanCombatReplay)
{
foreach (Player p in PlayerList)
{
if (p.Account == ":Conjured Sword")
{
continue;
}
p.InitCombatReplay(this, GeneralHelper.PollingRate, false, true);
}
foreach (Target tar in FightData.Logic.Targets)
{
tar.InitCombatReplay(this, GeneralHelper.PollingRate, true, FightData.GetMainTargets(this).Contains(tar));
}
FightData.Logic.InitTrashMobCombatReplay(this, GeneralHelper.PollingRate);
// Ensuring all combat replays are initialized before extra data (and agent interaction) is computed
foreach (Player p in PlayerList)
{
if (p.Account == ":Conjured Sword")
{
continue;
}
p.ComputeAdditionalCombatReplayData(this);
}
foreach (Target tar in FightData.Logic.Targets)
{
tar.ComputeAdditionalCombatReplayData(this);
}
foreach (Mob mob in FightData.Logic.TrashMobs)
{
mob.ComputeAdditionalCombatReplayData(this);
}
}
FightData.Logic.ComputeMechanics(this);
Statistics = new Statistics(this);
}
public void ComputeMechanics(ParsedLog log)
{
MechanicData mechData = log.MechanicData;
FightData fightData = log.FightData;
CombatData combatData = log.CombatData;
long start = fightData.FightStart;
long end = fightData.FightEnd;
Mechanic.CheckSpecialCondition condition;
HashSet <ushort> playersIds = new HashSet <ushort>(log.PlayerList.Select(x => x.InstID));
Dictionary <ushort, AbstractMasterPlayer> regroupedMobs = new Dictionary <ushort, AbstractMasterPlayer>();
foreach (Mechanic mech in MechanicList)
{
switch (mech.MechanicType)
{
case Mechanic.MechType.PlayerStatus:
foreach (Player p in log.PlayerList)
{
List <CombatItem> cList = new List <CombatItem>();
switch (mech.SkillId)
{
case SkillItem.DeathId:
cList = combatData.GetStates(p.InstID, ParseEnum.StateChange.ChangeDead, start, end);
break;
case SkillItem.DownId:
cList = combatData.GetStates(p.InstID, ParseEnum.StateChange.ChangeDown, start, end);
break;
case SkillItem.ResurrectId:
cList = log.GetCastData(p.InstID).Where(x => x.SkillID == SkillItem.ResurrectId && x.IsActivation.IsCasting()).ToList();
break;
}
foreach (CombatItem mechItem in cList)
{
mechData[mech].Add(new MechanicLog(mechItem.Time - start, mech, p));
}
}
break;
case Mechanic.MechType.SkillOnPlayer:
foreach (Player p in log.PlayerList)
{
List <DamageLog> dls = p.GetDamageTakenLogs(log, 0, fightData.FightDuration);
condition = mech.SpecialCondition;
foreach (DamageLog dLog in dls)
{
if (condition != null && !condition(new SpecialConditionItem(dLog)))
{
continue;
}
if (dLog.SkillId == mech.SkillId && dLog.Result.IsHit())
{
mechData[mech].Add(new MechanicLog(dLog.Time, mech, p));
}
}
}
break;
case Mechanic.MechType.PlayerBoon:
case Mechanic.MechType.PlayerOnPlayer:
case Mechanic.MechType.PlayerBoonRemove:
foreach (Player p in log.PlayerList)
{
condition = mech.SpecialCondition;
foreach (CombatItem c in log.GetBoonData(mech.SkillId))
{
if (condition != null && !condition(new SpecialConditionItem(c)))
{
continue;
}
if (mech.MechanicType == Mechanic.MechType.PlayerBoonRemove)
{
if (c.IsBuffRemove == ParseEnum.BuffRemove.Manual && p.InstID == c.SrcInstid)
{
mechData[mech].Add(new MechanicLog(c.Time - start, mech, p));
}
}
else
{
if (c.IsBuffRemove == ParseEnum.BuffRemove.None && p.InstID == c.DstInstid)
{
mechData[mech].Add(new MechanicLog(c.Time - start, mech, p));
if (mech.MechanicType == Mechanic.MechType.PlayerOnPlayer)
{
mechData[mech].Add(new MechanicLog(c.Time - start, mech, log.PlayerList.FirstOrDefault(x => x.InstID == c.SrcInstid)));
}
}
}
}
}
break;
case Mechanic.MechType.HitOnEnemy:
foreach (Player p in log.PlayerList)
{
condition = mech.SpecialCondition;
IEnumerable <AgentItem> agents = log.AgentData.GetAgentsByID((ushort)mech.SkillId);
foreach (AgentItem a in agents)
{
foreach (DamageLog dl in p.GetDamageLogs(null, log, 0, log.FightData.FightDuration))
{
if (dl.DstInstId != a.InstID || dl.IsCondi > 0 || dl.Time < a.FirstAware - start || dl.Time > a.LastAware - start || (condition != null && !condition(new SpecialConditionItem(dl))))
{
continue;
}
mechData[mech].Add(new MechanicLog(dl.Time, mech, p));
}
}
}
break;
case Mechanic.MechType.PlayerSkill:
foreach (Player p in log.PlayerList)
{
condition = mech.SpecialCondition;
foreach (CombatItem c in log.GetCastDataById(mech.SkillId))
{
if (condition != null && !condition(new SpecialConditionItem(c)))
{
continue;
}
if (c.IsActivation.IsCasting() && c.SrcInstid == p.InstID)
{
mechData[mech].Add(new MechanicLog(c.Time - fightData.FightStart, mech, p));
}
}
}
break;
case Mechanic.MechType.EnemyBoon:
case Mechanic.MechType.EnemyBoonStrip:
condition = mech.SpecialCondition;
foreach (CombatItem c in log.GetBoonData(mech.SkillId))
{
if (condition != null && !condition(new SpecialConditionItem(c)))
{
continue;
}
AbstractMasterPlayer amp = null;
if (mech.MechanicType == Mechanic.MechType.EnemyBoon && c.IsBuffRemove == ParseEnum.BuffRemove.None)
{
Boss target = Targets.Find(x => x.InstID == c.DstInstid && x.FirstAware <= c.Time && x.LastAware >= c.Time);
if (target != null)
{
amp = target;
}
else
{
AgentItem a = log.AgentData.GetAgent(c.DstAgent);
if (playersIds.Contains(a.InstID))
{
continue;
}
else if (a.MasterAgent != 0)
{
AgentItem m = log.AgentData.GetAgent(a.MasterAgent);
if (playersIds.Contains(m.InstID))
{
continue;
}
}
if (!regroupedMobs.TryGetValue(a.ID, out amp))
{
amp = new DummyPlayer(a);
regroupedMobs.Add(a.ID, amp);
}
}
}
else if (mech.MechanicType == Mechanic.MechType.EnemyBoonStrip && c.IsBuffRemove == ParseEnum.BuffRemove.Manual)
{
Boss target = Targets.Find(x => x.InstID == c.SrcInstid && x.FirstAware <= c.Time && x.LastAware >= c.Time);
if (target != null)
{
amp = target;
}
else
{
AgentItem a = log.AgentData.GetAgent(c.SrcAgent);
if (playersIds.Contains(a.InstID))
{
continue;
}
else if (a.MasterAgent != 0)
{
AgentItem m = log.AgentData.GetAgent(a.MasterAgent);
if (playersIds.Contains(m.InstID))
{
continue;
}
}
if (!regroupedMobs.TryGetValue(a.ID, out amp))
{
amp = new DummyPlayer(a);
regroupedMobs.Add(a.ID, amp);
}
}
}
if (amp != null)
{
mechData[mech].Add(new MechanicLog(c.Time - fightData.FightStart, mech, amp));
}
}
break;
case Mechanic.MechType.EnemyCastEnd:
case Mechanic.MechType.EnemyCastStart:
condition = mech.SpecialCondition;
foreach (CombatItem c in log.GetCastDataById(mech.SkillId))
{
if (condition != null && !condition(new SpecialConditionItem(c)))
{
continue;
}
AbstractMasterPlayer amp = null;
if ((mech.MechanicType == Mechanic.MechType.EnemyCastStart && c.IsActivation.IsCasting()) || (mech.MechanicType == Mechanic.MechType.EnemyCastEnd && !c.IsActivation.IsCasting()))
{
Boss target = Targets.Find(x => x.InstID == c.SrcInstid && x.FirstAware <= c.Time && x.LastAware >= c.Time);
if (target != null)
{
amp = target;
}
else
{
AgentItem a = log.AgentData.GetAgent(c.SrcAgent);
if (playersIds.Contains(a.InstID))
{
continue;
}
else if (a.MasterAgent != 0)
{
AgentItem m = log.AgentData.GetAgent(a.MasterAgent);
if (playersIds.Contains(m.InstID))
{
continue;
}
}
if (!regroupedMobs.TryGetValue(a.ID, out amp))
{
amp = new DummyPlayer(a);
regroupedMobs.Add(a.ID, amp);
}
}
}
if (amp != null)
{
mechData[mech].Add(new MechanicLog(c.Time - fightData.FightStart, mech, amp));
}
}
break;
case Mechanic.MechType.Spawn:
foreach (AgentItem a in log.AgentData.GetAgentByType(AgentItem.AgentType.NPC).Where(x => x.ID == mech.SkillId))
{
if (!regroupedMobs.TryGetValue(a.ID, out AbstractMasterPlayer amp))
{
amp = new DummyPlayer(a);
regroupedMobs.Add(a.ID, amp);
}
mechData[mech].Add(new MechanicLog(a.FirstAware - fightData.FightStart, mech, amp));
}
break;
}
}
mechData.ComputePresentMechanics(log);
}
internal JsonLog(ParsedEvtcLog log, RawFormatSettings settings, string[] uploadLinks)
{
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Meta Data");
TriggerID = log.FightData.TriggerID;
FightName = log.FightData.GetFightName(log);
FightIcon = log.FightData.Logic.Icon;
EliteInsightsVersion = log.ParserVersion.ToString();
ArcVersion = log.LogData.ArcVersion;
RecordedBy = log.LogData.PoVName;
TimeStart = log.LogData.LogStart;
TimeEnd = log.LogData.LogEnd;
TimeStartStd = log.LogData.LogStartStd;
TimeEndStd = log.LogData.LogEndStd;
Duration = log.FightData.DurationString;
Success = log.FightData.Success;
GW2Build = log.LogData.GW2Build;
UploadLinks = uploadLinks;
Language = log.LogData.Language;
LanguageID = (byte)log.LogData.LanguageID;
IsCM = log.FightData.IsCM;
if (log.Statistics.PresentFractalInstabilities.Any())
{
PresentFractalInstabilities = new List <long>();
foreach (Buff fractalInstab in log.Statistics.PresentFractalInstabilities)
{
PresentFractalInstabilities.Add(fractalInstab.ID);
if (!BuffMap.ContainsKey("b" + fractalInstab.ID))
{
BuffMap["b" + fractalInstab.ID] = new BuffDesc(fractalInstab, log);
}
}
}
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Mechanics");
MechanicData mechanicData = log.MechanicData;
var mechanicLogs = new List <MechanicEvent>();
foreach (List <MechanicEvent> mLog in mechanicData.GetAllMechanics(log))
{
mechanicLogs.AddRange(mLog);
}
if (mechanicLogs.Any())
{
Mechanics = GetJsonMechanicsList(mechanicLogs);
}
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Phases");
Phases = log.FightData.GetPhases(log).Select(x => new JsonPhase(x, log)).ToList();
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Targets");
Targets = log.FightData.Logic.Targets.Select(x => new JsonNPC(x, log, settings, SkillMap, BuffMap)).ToList();
//
log.UpdateProgressWithCancellationCheck("Raw Format: Building Players");
Players = log.PlayerList.Select(x => new JsonPlayer(x, log, settings, SkillMap, BuffMap, DamageModMap, PersonalBuffs)).ToList();
//
if (log.LogData.LogErrors.Count > 0)
{
LogErrors = new List <string>(log.LogData.LogErrors);
}
}
