protected void ComputeFightTargets(AgentData agentData, List <CombatItem> combatItems)
{
foreach (ushort id in GetUniqueTargetIDs())
{
RegroupTargetsByID(id, agentData, combatItems);
}
List <ushort> ids = GetFightTargetsIDs();
foreach (ushort id in ids)
{
List <AgentItem> agents = agentData.GetAgentsByID(id);
foreach (AgentItem agentItem in agents)
{
Targets.Add(new Target(agentItem));
}
}
List <ParseEnum.TrashIDS> ids2 = GetTrashMobsIDS();
List <AgentItem> aList = agentData.GetAgentByType(AgentItem.AgentType.NPC).Where(x => ids2.Contains(ParseEnum.GetTrashIDS(x.ID))).ToList();
foreach (AgentItem a in aList)
{
Mob mob = new Mob(a);
TrashMobs.Add(mob);
}
}
public override void SpecialParse(FightData fightData, AgentData agentData, List <CombatItem> combatData)
{
AgentItem dummyAgent = agentData.AddCustomAgent(combatData.First().LogTime, combatData.Last().LogTime, AgentItem.AgentType.NPC, "Enemy Players", "", TriggerID);
ComputeFightTargets(agentData, combatData);
List <AgentItem> aList = agentData.GetAgentByType(AgentItem.AgentType.EnemyPlayer).ToList();
/*foreach (AgentItem a in aList)
* {
* TrashMobs.Add(new Mob(a));
* }*/
Dictionary <ulong, AgentItem> enemyPlayerDicts = aList.GroupBy(x => x.Agent).ToDictionary(x => x.Key, x => x.ToList().First());
foreach (CombatItem c in combatData)
{
if (c.IsStateChange == ParseEnum.StateChange.None &&
c.IsActivation == ParseEnum.Activation.None &&
c.IsBuffRemove == ParseEnum.BuffRemove.None &&
((c.IsBuff != 0 && c.Value == 0) || (c.IsBuff == 0)))
{
if (enemyPlayerDicts.TryGetValue(c.SrcAgent, out AgentItem src))
{
c.OverrideSrcValues(dummyAgent.Agent, dummyAgent.InstID);
}
if (enemyPlayerDicts.TryGetValue(c.DstAgent, out AgentItem dst))
{
c.OverrideDstValues(dummyAgent.Agent, dummyAgent.InstID);
}
}
}
}
internal override void EIEvtcParse(FightData fightData, AgentData agentData, List <CombatItem> combatData, List <Player> playerList)
{
AgentItem dummyAgent = agentData.AddCustomAgent(fightData.FightStart, fightData.FightEnd, AgentItem.AgentType.NPC, "Enemy Players", "", (int)ArcDPSEnums.TargetID.WorldVersusWorld);
ComputeFightTargets(agentData, combatData);
var aList = agentData.GetAgentByType(AgentItem.AgentType.EnemyPlayer).ToList();
/*foreach (AgentItem a in aList)
* {
* TrashMobs.Add(new NPC(a));
* }*/
var enemyPlayerDicts = aList.GroupBy(x => x.Agent).ToDictionary(x => x.Key, x => x.ToList().First());
foreach (CombatItem c in combatData)
{
if (c.IsStateChange == ArcDPSEnums.StateChange.None &&
c.IsActivation == ArcDPSEnums.Activation.None &&
c.IsBuffRemove == ArcDPSEnums.BuffRemove.None &&
((c.IsBuff != 0 && c.Value == 0) || (c.IsBuff == 0)))
{
if (enemyPlayerDicts.TryGetValue(c.SrcAgent, out AgentItem src))
{
c.OverrideSrcAgent(dummyAgent.Agent);
}
if (enemyPlayerDicts.TryGetValue(c.DstAgent, out AgentItem dst))
{
c.OverrideDstAgent(dummyAgent.Agent);
}
}
}
}
public override void SpecialParse(FightData fightData, AgentData agentData, List <CombatItem> combatData)
{
Boss boss = Targets.Find(x => x.ID == (ushort)ParseEnum.BossIDS.Xera);
CombatItem enterCombat = combatData.Find(x => x.SrcInstid == boss.InstID && x.IsStateChange == ParseEnum.StateChange.EnterCombat);
if (enterCombat != null)
{
fightData.FightStart = enterCombat.Time;
}
foreach (AgentItem NPC in agentData.GetAgentByType(AgentItem.AgentType.NPC))
{
if (NPC.ID == 16286)
{
int xera2Instid = NPC.InstID;
boss.Health = 24085950;
fightData.PhaseData.Add(NPC.FirstAware);
boss.AgentItem.LastAware = NPC.LastAware;
foreach (CombatItem c in combatData)
{
if (c.SrcInstid == xera2Instid)
{
c.SrcInstid = boss.InstID;
c.SrcAgent = boss.Agent;
}
if (c.DstInstid == xera2Instid)
{
c.DstInstid = boss.InstID;
c.DstAgent = boss.Agent;
}
}
break;
}
}
}
internal virtual void ComputeFightTargets(AgentData agentData, List <CombatItem> combatItems)
{
foreach (int id in GetUniqueTargetIDs())
{
RegroupTargetsByID(id, agentData, combatItems);
}
List <int> ids = GetFightTargetsIDs();
foreach (int id in ids)
{
IReadOnlyList <AgentItem> agents = agentData.GetNPCsByID(id);
foreach (AgentItem agentItem in agents)
{
_targets.Add(new NPC(agentItem));
}
}
List <ArcDPSEnums.TrashID> ids2 = GetTrashMobsIDS();
var aList = agentData.GetAgentByType(AgentItem.AgentType.NPC).Where(x => ids2.Contains(ArcDPSEnums.GetTrashID(x.ID))).ToList();
//aList.AddRange(agentData.GetAgentByType(AgentItem.AgentType.Gadget).Where(x => ids2.Contains(ParseEnum.GetTrashIDS(x.ID))));
foreach (AgentItem a in aList)
{
_trashMobs.Add(new NPC(a));
}
}
public override void SpecialParse(FightData fightData, AgentData agentData, List <CombatItem> combatData)
{
ComputeFightTargets(agentData, combatData);
// Find target
Target target = Targets.Find(x => x.ID == (ushort)ParseEnum.TargetIDS.Deimos);
if (target == null)
{
throw new InvalidOperationException("Main target of the fight not found");
}
// enter combat
CombatItem enterCombat = combatData.FirstOrDefault(x => x.SrcInstid == target.InstID && x.IsStateChange == ParseEnum.StateChange.EnterCombat && x.SrcInstid == target.InstID && x.LogTime <= target.LastAwareLogTime && x.LogTime >= target.FirstAwareLogTime);
if (enterCombat != null)
{
fightData.OverrideStart(enterCombat.LogTime);
}
// Remove deimos despawn events as they are useless and mess with combat replay
combatData.RemoveAll(x => x.IsStateChange == ParseEnum.StateChange.Despawn && x.SrcAgent == target.Agent);
// invul correction
CombatItem invulApp = combatData.FirstOrDefault(x => x.DstInstid == target.InstID && x.IsBuff != 0 && x.BuffDmg == 0 && x.Value > 0 && x.SkillID == 762);
if (invulApp != null)
{
invulApp.OverrideValue((int)(target.LastAwareLogTime - invulApp.LogTime));
}
// Deimos gadgets
CombatItem targetable = combatData.LastOrDefault(x => x.IsStateChange == ParseEnum.StateChange.Targetable && x.LogTime > combatData.First().LogTime&& x.DstAgent > 0);
HashSet <ulong> gadgetAgents = new HashSet <ulong>();
long firstAware = AttackTargetSpecialParse(targetable, agentData, combatData, gadgetAgents);
// legacy method
if (firstAware == 0)
{
CombatItem armDeimosDamageEvent = combatData.FirstOrDefault(x => x.LogTime >= target.LastAwareLogTime && (x.SkillID == 37980 || x.SkillID == 37982 || x.SkillID == 38046) && x.SrcAgent != 0 && x.SrcInstid != 0);
if (armDeimosDamageEvent != null)
{
List <AgentItem> deimosGadgets = agentData.GetAgentByType(AgentItem.AgentType.Gadget).Where(x => x.Name.Contains("Deimos") && x.LastAwareLogTime > armDeimosDamageEvent.LogTime).ToList();
if (deimosGadgets.Count > 0)
{
firstAware = deimosGadgets.Max(x => x.FirstAwareLogTime);
gadgetAgents = new HashSet <ulong>(deimosGadgets.Select(x => x.Agent));
}
}
}
if (gadgetAgents.Count > 0)
{
_specialSplitLogTime = (firstAware >= target.LastAwareLogTime ? firstAware : target.LastAwareLogTime);
SetUniqueID(target.AgentItem, gadgetAgents, agentData, combatData);
}
target.AgentItem.LastAwareLogTime = combatData.Last().LogTime;
}
private void CompleteAgents()
{
var agentsLookup = _allAgentsList.GroupBy(x => x.Agent).ToDictionary(x => x.Key, x => x.ToList().First());
//var agentsLookup = _allAgentsList.ToDictionary(x => x.Agent);
// Set Agent instid, firstAware and lastAware
foreach (CombatItem c in _combatItems)
{
if (c.IsStateChange.SrcIsAgent())
{
if (agentsLookup.TryGetValue(c.SrcAgent, out AgentItem agent))
{
UpdateAgentData(agent, c.Time, c.SrcInstid);
}
}
if (c.IsStateChange.DstIsAgent())
{
if (agentsLookup.TryGetValue(c.DstAgent, out AgentItem agent))
{
UpdateAgentData(agent, c.Time, c.DstInstid);
}
}
}
_allAgentsList.RemoveAll(x => !(x.InstID != 0 && x.LastAware - x.FirstAware >= 0 && x.FirstAware != 0 && x.LastAware != long.MaxValue) && (x.Type != AgentItem.AgentType.Player && x.Type != AgentItem.AgentType.EnemyPlayer));
_agentData = new AgentData(_allAgentsList);
if (_agentData.GetAgentByType(AgentItem.AgentType.Player).Count == 0)
{
throw new EvtcAgentException("No players found");
}
_fightData = new FightData(_id, _agentData, _parserSettings, _logStartTime, _logEndTime);
CompletePlayers();
foreach (CombatItem c in _combatItems)
{
if (c.IsStateChange.SrcIsAgent() && c.SrcMasterInstid != 0)
{
FindAgentMaster(c.Time, c.SrcMasterInstid, c.SrcAgent);
}
if (c.IsStateChange.DstIsAgent() && c.DstMasterInstid != 0)
{
FindAgentMaster(c.Time, c.DstMasterInstid, c.DstAgent);
}
}
}
public override void SpecialParse(FightData fightData, AgentData agentData, List <CombatItem> combatData)
{
Boss boss = Targets.Find(x => x.ID == (ushort)ParseEnum.BossIDS.Deimos);
if (boss == null)
{
throw new InvalidOperationException("Main target of the fight not found");
}
CombatItem enterCombat = combatData.FirstOrDefault(x => x.SrcInstid == boss.InstID && x.IsStateChange == ParseEnum.StateChange.EnterCombat);
if (enterCombat != null)
{
fightData.FightStart = enterCombat.Time;
}
List <AgentItem> deimosGadgets = agentData.GetAgentByType(AgentItem.AgentType.Gadget).Where(x => x.Name.Contains("Deimos")).OrderBy(x => x.LastAware).ToList();
if (deimosGadgets.Count > 0)
{
long firstAware = deimosGadgets.Max(x => x.FirstAware);
HashSet <ulong> deimos2Agents = new HashSet <ulong>(deimosGadgets.Select(x => x.Agent));
CombatItem targetable = combatData.LastOrDefault(x => x.IsStateChange == ParseEnum.StateChange.Targetable && x.Time > combatData.First().Time&& x.DstAgent > 0);
if (targetable != null)
{
firstAware = targetable.Time;
}
long oldAware = boss.LastAware;
fightData.PhaseData.Add(firstAware >= oldAware ? firstAware : oldAware);
boss.AgentItem.LastAware = deimosGadgets.Max(x => x.LastAware);
foreach (CombatItem c in combatData)
{
if (c.Time > oldAware)
{
if (deimos2Agents.Contains(c.SrcAgent))
{
c.SrcInstid = boss.InstID;
c.SrcAgent = boss.Agent;
}
if (deimos2Agents.Contains(c.DstAgent))
{
c.DstInstid = boss.InstID;
c.DstAgent = boss.Agent;
}
}
}
}
}
public override void EIEvtcParse(FightData fightData, AgentData agentData, List <CombatItem> combatData, List <Player> playerList)
{
ComputeFightTargets(agentData, combatData);
// Find target
NPC target = Targets.Find(x => x.ID == (int)ParseEnum.TargetIDS.Deimos);
if (target == null)
{
throw new InvalidOperationException("Deimos not found");
}
// Remove deimos despawn events as they are useless and mess with combat replay
combatData.RemoveAll(x => x.IsStateChange == ParseEnum.StateChange.Despawn && x.SrcAgent == target.Agent);
// invul correction
CombatItem invulApp = combatData.FirstOrDefault(x => x.DstAgent == target.Agent && x.IsBuff != 0 && x.BuffDmg == 0 && x.Value > 0 && x.SkillID == 762 && x.IsStateChange == ParseEnum.StateChange.None);
if (invulApp != null)
{
invulApp.OverrideValue((int)(target.LastAware - invulApp.Time));
}
// Deimos gadgets
CombatItem targetable = combatData.LastOrDefault(x => x.IsStateChange == ParseEnum.StateChange.Targetable && x.DstAgent > 0);
var gadgetAgents = new HashSet <ulong>();
long firstAware = AttackTargetSpecialParse(targetable, agentData, combatData, gadgetAgents);
// legacy method
if (firstAware == 0)
{
CombatItem armDeimosDamageEvent = combatData.FirstOrDefault(x => x.Time >= target.LastAware && (x.SkillID == 37980 || x.SkillID == 37982 || x.SkillID == 38046) && x.SrcAgent != 0 && x.SrcInstid != 0);
if (armDeimosDamageEvent != null)
{
var deimosGadgets = agentData.GetAgentByType(AgentItem.AgentType.Gadget).Where(x => x.Name.Contains("Deimos") && x.LastAware > armDeimosDamageEvent.Time).ToList();
if (deimosGadgets.Count > 0)
{
firstAware = deimosGadgets.Max(x => x.FirstAware);
gadgetAgents = new HashSet <ulong>(deimosGadgets.Select(x => x.Agent));
}
}
}
if (gadgetAgents.Count > 0)
{
_specialSplit = (firstAware >= target.LastAware ? firstAware : target.LastAware);
MergeWithGadgets(target.AgentItem, gadgetAgents, agentData, combatData);
}
target.AgentItem.OverrideAwareTimes(target.FirstAware, fightData.FightEnd);
target.OverrideName("Deimos");
}
public override void EIEvtcParse(FightData fightData, AgentData agentData, List <CombatItem> combatData, List <Player> playerList)
{
// find target
AgentItem target = agentData.GetNPCsByID((int)ParseEnum.TargetIDS.Xera).FirstOrDefault();
if (target == null)
{
throw new InvalidOperationException("Error Encountered: Xera not found");
}
// find split
foreach (AgentItem NPC in agentData.GetAgentByType(AgentItem.AgentType.NPC))
{
if (NPC.ID == 16286)
{
CombatItem move = combatData.FirstOrDefault(x => x.IsStateChange == ParseEnum.StateChange.Position && x.SrcAgent == NPC.Agent && x.Time >= NPC.FirstAware + 500);
if (move != null)
{
_specialSplit = move.Time;
}
else
{
_specialSplit = NPC.FirstAware;
}
target.OverrideAwareTimes(target.FirstAware, NPC.LastAware);
agentData.SwapMasters(NPC, target);
var agents = new HashSet <ulong>()
{
NPC.Agent, target.Agent
};
// update combat data
foreach (CombatItem c in combatData)
{
if (agents.Contains(c.SrcAgent) && c.IsStateChange.SrcIsAgent())
{
c.OverrideSrcAgent(target.Agent);
}
if (agents.Contains(c.DstAgent) && c.IsStateChange.DstIsAgent())
{
c.OverrideDstAgent(target.Agent);
}
}
break;
}
}
ComputeFightTargets(agentData, combatData);
}
internal virtual void ComputeFightTargets(AgentData agentData, List <CombatItem> combatItems, IReadOnlyDictionary <uint, AbstractExtensionHandler> extensions)
{
foreach (int id in GetUniqueNPCIDs())
{
RegroupTargetsByID(id, agentData, combatItems, extensions);
}
//
List <int> targetIDs = GetTargetsIDs();
foreach (int id in targetIDs)
{
IReadOnlyList <AgentItem> agents = agentData.GetNPCsByID(id);
foreach (AgentItem agentItem in agents)
{
_targets.Add(new NPC(agentItem));
}
}
_targets.Sort((x, y) => x.FirstAware.CompareTo(y.FirstAware));
//
List <ArcDPSEnums.TrashID> trashIDs = GetTrashMobsIDs();
var aList = agentData.GetAgentByType(AgentItem.AgentType.NPC).Where(x => trashIDs.Contains(ArcDPSEnums.GetTrashID(x.ID))).ToList();
//aList.AddRange(agentData.GetAgentByType(AgentItem.AgentType.Gadget).Where(x => ids2.Contains(ParseEnum.GetTrashIDS(x.ID))));
foreach (AgentItem a in aList)
{
_trashMobs.Add(new NPC(a));
}
_trashMobs.Sort((x, y) => x.FirstAware.CompareTo(y.FirstAware));
//
List <int> friendlyNPCIDs = GetFriendlyNPCIDs();
foreach (int id in friendlyNPCIDs)
{
IReadOnlyList <AgentItem> agents = agentData.GetNPCsByID(id);
foreach (AgentItem agentItem in agents)
{
_nonPlayerFriendlies.Add(new NPC(agentItem));
}
}
_nonPlayerFriendlies.Sort((x, y) => x.FirstAware.CompareTo(y.FirstAware));
//
TargetAgents = new HashSet <AgentItem>(_targets.Select(x => x.AgentItem));
NonPlayerFriendlyAgents = new HashSet <AgentItem>(_nonPlayerFriendlies.Select(x => x.AgentItem));
TrashMobAgents = new HashSet <AgentItem>(_trashMobs.Select(x => x.AgentItem));
}
internal override void EIEvtcParse(ulong gw2Build, FightData fightData, AgentData agentData, List <CombatItem> combatData, List <AbstractSingleActor> friendlies, IReadOnlyDictionary <uint, AbstractExtensionHandler> extensions)
{
AgentItem dummyAgent = agentData.AddCustomAgent(0, fightData.FightEnd, AgentItem.AgentType.NPC, _detailed ? "Dummy WvW Agent" : "Enemy Players", ParserHelper.Spec.NPC, (int)ArcDPSEnums.TargetID.WorldVersusWorld, true);
SolveWvWPlayers(agentData, combatData, friendlies, extensions);
var friendlyAgents = new HashSet <AgentItem>(friendlies.Select(x => x.AgentItem));
if (!_detailed)
{
var aList = agentData.GetAgentByType(AgentItem.AgentType.NonSquadPlayer).Where(x => !friendlyAgents.Contains(x)).ToList();
var enemyPlayerDicts = aList.GroupBy(x => x.Agent).ToDictionary(x => x.Key, x => x.ToList());
foreach (CombatItem c in combatData)
{
if (c.IsDamage(extensions))
{
if (enemyPlayerDicts.TryGetValue(c.SrcAgent, out List <AgentItem> srcs))
{
foreach (AgentItem src in srcs)
{
if (c.SrcMatchesAgent(src, extensions))
{
c.OverrideSrcAgent(dummyAgent.Agent);
break;
}
}
}
if (enemyPlayerDicts.TryGetValue(c.DstAgent, out List <AgentItem> dsts))
{
foreach (AgentItem dst in dsts)
{
if (c.DstMatchesAgent(dst, extensions))
{
c.OverrideDstAgent(dummyAgent.Agent);
break;
}
}
}
}
}
}
ComputeFightTargets(agentData, combatData, extensions);
}
protected FightLogic(ushort triggerID, AgentData agentData)
{
TriggerID = triggerID;
HasCombatReplayMap = GetCombatMap() != null;
MechanicList = new List <Mechanic>()
{
new PlayerStatusMechanic(SkillItem.DeathId, "Dead", new MechanicPlotlySetting("x", "rgb(0,0,0)"), "Dead", 0),
new PlayerStatusMechanic(SkillItem.DownId, "Downed", new MechanicPlotlySetting("cross", "rgb(255,0,0)"), "Downed", 0),
new PlayerStatusMechanic(SkillItem.ResurrectId, "Resurrect", new MechanicPlotlySetting("cross-open", "rgb(0,255,255)"), "Res", 0),
new PlayerStatusMechanic(SkillItem.AliveId, "Got up", new MechanicPlotlySetting("cross", "rgb(0,255,0)"), "Got up", 0),
new PlayerStatusMechanic(SkillItem.DCId, "Disconnected", new MechanicPlotlySetting("x", "rgb(120,120,120)"), "DC", 0),
new PlayerStatusMechanic(SkillItem.RespawnId, "Respawn", new MechanicPlotlySetting("cross", "rgb(120,120,255)"), "Resp", 0)
};
_basicMechanicsCount = MechanicList.Count;
List <ParseEnum.TrashIDS> ids = GetTrashMobsIDS();
List <AgentItem> aList = agentData.GetAgentByType(AgentItem.AgentType.NPC).Where(x => ids.Contains(ParseEnum.GetTrashIDS(x.ID))).ToList();
foreach (AgentItem a in aList)
{
Mob mob = new Mob(a);
TrashMobs.Add(mob);
}
}
public override List <InstantCastEvent> ComputeInstantCast(CombatData combatData, SkillData skillData, AgentData agentData)
{
var res = new List <InstantCastEvent>();
foreach (AgentItem playerAgent in agentData.GetAgentByType(AgentItem.AgentType.Player))
{
IReadOnlyList <WeaponSwapEvent> swaps = combatData.GetWeaponSwapData(playerAgent);
long lastTime = int.MinValue;
foreach (WeaponSwapEvent swap in swaps)
{
if (swap.SwappedTo != _swappedTo)
{
continue;
}
if (swap.Time - lastTime < ICD)
{
lastTime = swap.Time;
continue;
}
if (_triggerCondition != null)
{
if (_triggerCondition(swap, combatData, skillData))
{
lastTime = swap.Time;
res.Add(new InstantCastEvent(swap.Time, skillData.Get(SkillID), swap.Caster));
}
}
else
{
lastTime = swap.Time;
res.Add(new InstantCastEvent(swap.Time, skillData.Get(SkillID), swap.Caster));
}
}
}
return(res);
}
private void CompletePlayers()
{
//Fix Disconnected players
var playerAgentList = _agentData.GetAgentByType(AgentItem.AgentType.Player);
foreach (AgentItem playerAgent in playerAgentList)
{
if (playerAgent.InstID == 0 || playerAgent.FirstAware == 0 || playerAgent.LastAware == long.MaxValue)
{
CombatItem tst = _combatItems.Find(x => x.SrcAgent == playerAgent.Agent);
if (tst == null)
{
tst = _combatItems.Find(x => x.DstAgent == playerAgent.Agent);
if (tst == null)
{
continue;
}
playerAgent.InstID = tst.DstInstid;
}
else
{
playerAgent.InstID = tst.SrcInstid;
}
playerAgent.FirstAware = _fightData.FightStart;
playerAgent.LastAware = _fightData.FightEnd;
}
try
{
bool skip = false;
Player player = new Player(playerAgent, _fightData.Logic.Mode == FightLogic.ParseMode.Fractal);
foreach (Player p in _playerList)
{
if (p.Account == player.Account) // same player
{
if (p.Character == player.Character) // same character, can be fused
{
skip = true;
Random rnd = new Random();
ulong agent = 0;
while (_agentData.AgentValues.Contains(agent) || agent == 0)
{
agent = (ulong)rnd.Next(Int32.MaxValue / 2, Int32.MaxValue);
}
ushort instid = 0;
while (_agentData.InstIDValues.Contains(instid) || instid == 0)
{
instid = (ushort)rnd.Next(ushort.MaxValue / 2, ushort.MaxValue);
}
foreach (CombatItem c in _combatItems)
{
if (c.DstAgent == p.Agent || player.Agent == c.DstAgent)
{
c.OverrideDstValues(agent, instid);
}
if (c.SrcAgent == p.Agent || player.Agent == c.SrcAgent)
{
c.OverrideSrcValues(agent, instid);
}
}
p.AgentItem.InstID = instid;
p.AgentItem.Agent = agent;
p.AgentItem.FirstAware = Math.Min(p.AgentItem.FirstAware, player.AgentItem.FirstAware);
p.AgentItem.LastAware = Math.Max(p.AgentItem.LastAware, player.AgentItem.LastAware);
_agentData.Refresh();
break;
}
// different character in raid mode, discard it as it can't have any influence, otherwise add as a separate entity
else if (_fightData.Logic.Mode == FightLogic.ParseMode.Raid)
{
skip = true;
break;
}
}
}
if (!skip)
{
_playerList.Add(player);
}
} catch (InvalidPlayerException ex)
{
if (_fightData.Logic.Mode != FightLogic.ParseMode.WvW)
{
throw ex;
}
// the players are enemy
/*if (!ex.Squadless)
* {
* _fightData.Logic.Targets.Add(new Target(playerAgent));
* }*/
}
}
}
private void SolveWvWPlayers(AgentData agentData, List <CombatItem> combatData, List <AbstractSingleActor> friendlies, IReadOnlyDictionary <uint, AbstractExtensionHandler> extensions)
{
IReadOnlyList <AgentItem> aList = agentData.GetAgentByType(AgentItem.AgentType.NonSquadPlayer);
var set = new HashSet <string>();
var toRemove = new HashSet <AgentItem>();
var garbageList = new List <AbstractSingleActor>();
var teamChangeDict = combatData.Where(x => x.IsStateChange == ArcDPSEnums.StateChange.TeamChange).GroupBy(x => x.SrcAgent).ToDictionary(x => x.Key, x => x.ToList());
//
IReadOnlyList <AgentItem> squadPlayers = agentData.GetAgentByType(AgentItem.AgentType.Player);
ulong greenTeam = ulong.MaxValue;
var greenTeams = new List <ulong>();
foreach (AgentItem a in squadPlayers)
{
if (teamChangeDict.TryGetValue(a.Agent, out List <CombatItem> teamChangeList))
{
greenTeams.AddRange(teamChangeList.Where(x => x.SrcMatchesAgent(a)).Select(x => x.DstAgent));
}
}
if (greenTeams.Any())
{
greenTeam = greenTeams.GroupBy(x => x).OrderByDescending(x => x.Count()).Select(x => x.Key).First();
}
var playersToMerge = new Dictionary <PlayerNonSquad, AbstractSingleActor>();
var agentsToPlayersToMerge = new Dictionary <ulong, PlayerNonSquad>();
//
foreach (AgentItem a in aList)
{
if (teamChangeDict.TryGetValue(a.Agent, out List <CombatItem> teamChangeList))
{
a.OverrideIsNotInSquadFriendlyPlayer(teamChangeList.Where(x => x.SrcMatchesAgent(a)).Select(x => x.DstAgent).Any(x => x == greenTeam));
}
List <AbstractSingleActor> actorListToFill = a.IsNotInSquadFriendlyPlayer ? friendlies : _detailed ? _targets : garbageList;
var nonSquadPlayer = new PlayerNonSquad(a);
if (!set.Contains(nonSquadPlayer.Character))
{
actorListToFill.Add(nonSquadPlayer);
set.Add(nonSquadPlayer.Character);
}
else
{
// we merge
AbstractSingleActor mainPlayer = actorListToFill.FirstOrDefault(x => x.Character == nonSquadPlayer.Character);
playersToMerge[nonSquadPlayer] = mainPlayer;
agentsToPlayersToMerge[nonSquadPlayer.AgentItem.Agent] = nonSquadPlayer;
}
}
if (playersToMerge.Any())
{
foreach (CombatItem c in combatData)
{
if (agentsToPlayersToMerge.TryGetValue(c.SrcAgent, out PlayerNonSquad nonSquadPlayer) && c.SrcMatchesAgent(nonSquadPlayer.AgentItem, extensions))
{
AbstractSingleActor mainPlayer = playersToMerge[nonSquadPlayer];
c.OverrideSrcAgent(mainPlayer.AgentItem.Agent);
}
if (agentsToPlayersToMerge.TryGetValue(c.DstAgent, out nonSquadPlayer) && c.DstMatchesAgent(nonSquadPlayer.AgentItem, extensions))
{
AbstractSingleActor mainPlayer = playersToMerge[nonSquadPlayer];
c.OverrideDstAgent(mainPlayer.AgentItem.Agent);
}
}
foreach (KeyValuePair <PlayerNonSquad, AbstractSingleActor> pair in playersToMerge)
{
PlayerNonSquad nonSquadPlayer = pair.Key;
AbstractSingleActor mainPlayer = pair.Value;
agentData.SwapMasters(nonSquadPlayer.AgentItem, mainPlayer.AgentItem);
mainPlayer.AgentItem.OverrideAwareTimes(Math.Min(nonSquadPlayer.FirstAware, mainPlayer.FirstAware), Math.Max(nonSquadPlayer.LastAware, mainPlayer.LastAware));
toRemove.Add(nonSquadPlayer.AgentItem);
}
}
agentData.RemoveAllFrom(toRemove);
}
private void CompleteAgents(ParserController operation)
{
var agentsLookup = _allAgentsList.GroupBy(x => x.Agent).ToDictionary(x => x.Key, x => x.ToList());
//var agentsLookup = _allAgentsList.ToDictionary(x => x.Agent);
// Set Agent instid, firstAware and lastAware
var invalidCombatItems = new HashSet <CombatItem>();
foreach (CombatItem c in _combatItems)
{
if (c.SrcIsAgent())
{
if (agentsLookup.TryGetValue(c.SrcAgent, out List <AgentItem> agents))
{
bool updatedAgent = false;
foreach (AgentItem agent in agents)
{
updatedAgent = UpdateAgentData(agent, c.Time, c.SrcInstid, agents.Count > 1);
if (updatedAgent)
{
break;
}
}
// this means that this particular combat item does not point to a proper agent
if (!updatedAgent && c.SrcInstid != 0)
{
invalidCombatItems.Add(c);
}
}
}
if (c.DstIsAgent())
{
if (agentsLookup.TryGetValue(c.DstAgent, out List <AgentItem> agents))
{
bool updatedAgent = false;
foreach (AgentItem agent in agents)
{
updatedAgent = UpdateAgentData(agent, c.Time, c.DstInstid, agents.Count > 1);
if (updatedAgent)
{
break;
}
}
// this means that this particular combat item does not point to a proper agent
if (!updatedAgent && c.DstInstid != 0)
{
invalidCombatItems.Add(c);
}
}
}
}
if (invalidCombatItems.Any())
{
#if DEBUG
throw new InvalidDataException("Must remove " + invalidCombatItems.Count + " invalid combat items");
#else
operation.UpdateProgressWithCancellationCheck("Removing " + invalidCombatItems.Count + " invalid combat items");
_combatItems.RemoveAll(x => invalidCombatItems.Contains(x));
#endif
}
_allAgentsList.RemoveAll(x => !(x.InstID != 0 && x.LastAware - x.FirstAware >= 0 && x.FirstAware != 0 && x.LastAware != long.MaxValue) && (x.Type != AgentItem.AgentType.Player && x.Type != AgentItem.AgentType.NonSquadPlayer));
_agentData = new AgentData(_allAgentsList);
if (_agentData.GetAgentByType(AgentItem.AgentType.Player).Count == 0)
{
throw new EvtcAgentException("No players found");
}
_fightData = new FightData(_id, _agentData, _parserSettings, _logStartTime, _logEndTime);
operation.UpdateProgressWithCancellationCheck("Linking minions to their masters");
foreach (CombatItem c in _combatItems)
{
if (c.SrcIsAgent() && c.SrcMasterInstid != 0)
{
FindAgentMaster(c.Time, c.SrcMasterInstid, c.SrcAgent);
}
if (c.DstIsAgent() && c.DstMasterInstid != 0)
{
FindAgentMaster(c.Time, c.DstMasterInstid, c.DstAgent);
}
}
// Adjust extension events if needed
if (_enabledExtensions.Any())
{
operation.UpdateProgressWithCancellationCheck("Adjust extension events");
foreach (CombatItem combatItem in _combatItems)
{
if (combatItem.IsExtension)
{
if (_enabledExtensions.TryGetValue(combatItem.Pad, out AbstractExtensionHandler handler))
{
handler.AdjustCombatEvent(combatItem, _agentData);
}
}
}
}
operation.UpdateProgressWithCancellationCheck("Creating players");
CompletePlayers(operation);
}
private void CompletePlayers(ParserController operation)
{
//Fix Disconnected players
IReadOnlyList <AgentItem> playerAgentList = _agentData.GetAgentByType(AgentItem.AgentType.Player);
foreach (AgentItem playerAgent in playerAgentList)
{
if (playerAgent.InstID == 0 || playerAgent.FirstAware == 0 || playerAgent.LastAware == long.MaxValue)
{
operation.UpdateProgressWithCancellationCheck("Skipping invalid player " + playerAgent.Name);
continue;
}
bool skip = false;
var player = new Player(playerAgent, _fightData.Logic.Mode == FightLogic.ParseMode.Instanced5 || _fightData.Logic.Mode == FightLogic.ParseMode.sPvP);
foreach (Player p in _playerList)
{
if (p.Account == player.Account) // same player
{
if (p.Character == player.Character) // same character, can be fused
{
skip = true;
ulong agent = p.AgentItem.Agent;
operation.UpdateProgressWithCancellationCheck("Merging player " + p.Character);
foreach (CombatItem c in _combatItems)
{
if (c.DstMatchesAgent(player.AgentItem, _enabledExtensions))
{
c.OverrideDstAgent(agent);
}
if (c.SrcMatchesAgent(player.AgentItem, _enabledExtensions))
{
c.OverrideSrcAgent(agent);
}
}
_agentData.SwapMasters(player.AgentItem, p.AgentItem);
p.AgentItem.OverrideAwareTimes(Math.Min(p.AgentItem.FirstAware, player.AgentItem.FirstAware), Math.Max(p.AgentItem.LastAware, player.AgentItem.LastAware));
break;
}
}
}
if (!skip)
{
_playerList.Add(player);
}
}
if (_parserSettings.AnonymousPlayer)
{
for (int i = 0; i < _playerList.Count; i++)
{
_playerList[i].Anonymize(i + 1);
}
}
_playerList = _playerList.OrderBy(a => a.Group).ToList();
if (_playerList.Exists(x => x.Group == 0))
{
_playerList.ForEach(x => x.MakeSquadless());
}
uint minToughness = _playerList.Min(x => x.Toughness);
if (minToughness > 0)
{
operation.UpdateProgressWithCancellationCheck("Adjusting player toughness scores");
uint maxToughness = _playerList.Max(x => x.Toughness);
foreach (Player p in _playerList)
{
p.AgentItem.OverrideToughness((ushort)Math.Round(10.0 * (p.AgentItem.Toughness - minToughness) / Math.Max(1.0, maxToughness - minToughness)));
}
}
}
internal override void EIEvtcParse(FightData fightData, AgentData agentData, List <CombatItem> combatData, List <Player> playerList)
{
AgentItem dummyAgent = agentData.AddCustomAgent(fightData.FightStart, fightData.FightEnd, AgentItem.AgentType.NPC, _detailed ? "Dummy WvW Agent" : "Enemy Players", "", (int)ArcDPSEnums.TargetID.WorldVersusWorld, true);
ComputeFightTargets(agentData, combatData);
IReadOnlyList <AgentItem> aList = agentData.GetAgentByType(AgentItem.AgentType.EnemyPlayer);
if (_detailed)
{
var set = new HashSet <string>();
foreach (AgentItem a in aList)
{
var npc = new NPC(a);
if (!set.Contains(npc.Character))
{
_targets.Add(npc);
set.Add(npc.Character);
}
else
{
// we merge
NPC mainNPC = _targets.FirstOrDefault(x => x.Character == npc.Character);
foreach (CombatItem c in combatData)
{
if (c.IsStateChange.SrcIsAgent() && c.SrcAgent == npc.Agent)
{
c.OverrideSrcAgent(mainNPC.Agent);
}
if (c.IsStateChange.DstIsAgent() && c.DstAgent == npc.Agent)
{
c.OverrideDstAgent(mainNPC.Agent);
}
}
agentData.SwapMasters(npc.AgentItem, mainNPC.AgentItem);
mainNPC.AgentItem.OverrideAwareTimes(Math.Min(npc.FirstAware, mainNPC.FirstAware), Math.Max(npc.LastAware, mainNPC.LastAware));
}
}
}
else
{
var enemyPlayerDicts = aList.GroupBy(x => x.Agent).ToDictionary(x => x.Key, x => x.ToList().First());
foreach (CombatItem c in combatData)
{
if (c.IsStateChange == ArcDPSEnums.StateChange.None &&
c.IsActivation == ArcDPSEnums.Activation.None &&
c.IsBuffRemove == ArcDPSEnums.BuffRemove.None &&
((c.IsBuff != 0 && c.Value == 0) || (c.IsBuff == 0)))
{
if (enemyPlayerDicts.TryGetValue(c.SrcAgent, out AgentItem src))
{
c.OverrideSrcAgent(dummyAgent.Agent);
}
if (enemyPlayerDicts.TryGetValue(c.DstAgent, out AgentItem dst))
{
c.OverrideDstAgent(dummyAgent.Agent);
}
}
}
}
}
public override void SpecialParse(FightData fightData, AgentData agentData, List <CombatItem> combatData)
{
// find target
Target target = Targets.Find(x => x.ID == (ushort)ParseEnum.TargetIDS.Xera);
if (target == null)
{
throw new InvalidOperationException("Main target of the fight not found");
}
// enter combat
CombatItem enterCombat = combatData.Find(x => x.SrcInstid == target.InstID && x.IsStateChange == ParseEnum.StateChange.EnterCombat);
if (enterCombat != null)
{
fightData.FightStart = enterCombat.Time;
}
// find split
foreach (AgentItem NPC in agentData.GetAgentByType(AgentItem.AgentType.NPC))
{
if (NPC.ID == 16286)
{
target.Health = 24085950;
CombatItem move = combatData.FirstOrDefault(x => x.IsStateChange == ParseEnum.StateChange.Position && x.SrcInstid == NPC.InstID && x.Time >= NPC.FirstAware + 500 && x.Time <= NPC.LastAware);
if (move != null)
{
_specialSplit = move.Time;
}
else
{
_specialSplit = NPC.FirstAware;
}
target.AgentItem.LastAware = NPC.LastAware;
// get unique id for the fusion
ushort instID = 0;
Random rnd = new Random();
while (agentData.InstIDValues.Contains(instID) || instID == 0)
{
instID = (ushort)rnd.Next(ushort.MaxValue / 2, ushort.MaxValue);
}
target.AgentItem.InstID = instID;
agentData.Refresh();
HashSet <ulong> agents = new HashSet <ulong>()
{
NPC.Agent, target.Agent
};
// update combat data
foreach (CombatItem c in combatData)
{
if (agents.Contains(c.SrcAgent))
{
c.OverrideSrcValues(target.Agent, target.InstID);
}
if (agents.Contains(c.DstAgent))
{
c.OverrideDstValues(target.Agent, target.InstID);
}
}
break;
}
}
}
private void CompleteAgents()
{
var agentsLookup = _allAgentsList.GroupBy(x => x.Agent).ToDictionary(x => x.Key, x => x.ToList());;
// Set Agent instid, firstAware and lastAware
foreach (CombatItem c in _combatItems)
{
if (agentsLookup.TryGetValue(c.SrcAgent, out var agentList))
{
foreach (AgentItem agent in agentList)
{
if (agent.InstID == 0)
{
agent.InstID = c.IsStateChange != ParseEnum.StateChange.None ? c.SrcInstid : (ushort)0;
if (agent.FirstAwareLogTime == 0)
{
agent.FirstAwareLogTime = c.LogTime;
}
agent.LastAwareLogTime = c.LogTime;
break;
}
else if (agent.InstID == c.SrcInstid)
{
agent.LastAwareLogTime = c.LogTime;
break;
}
}
}
// An attack target could appear slightly before its master, this properly updates the time if it happens
if (c.IsStateChange == ParseEnum.StateChange.AttackTarget && agentsLookup.TryGetValue(c.DstAgent, out agentList))
{
foreach (AgentItem agent in agentList)
{
if (agent.InstID == 0)
{
agent.InstID = c.DstInstid;
if (agent.FirstAwareLogTime == 0)
{
agent.FirstAwareLogTime = c.LogTime;
}
agent.LastAwareLogTime = c.LogTime;
break;
}
else if (agent.InstID == c.DstInstid)
{
agent.LastAwareLogTime = c.LogTime;
break;
}
}
}
}
foreach (CombatItem c in _combatItems)
{
if (c.SrcMasterInstid != 0)
{
var master = _allAgentsList.Find(x => x.InstID == c.SrcMasterInstid && x.FirstAwareLogTime <= c.LogTime && c.LogTime <= x.LastAwareLogTime);
if (master != null)
{
if (agentsLookup.TryGetValue(c.SrcAgent, out var minionList))
{
foreach (AgentItem minion in minionList)
{
if (minion.FirstAwareLogTime <= c.LogTime && c.LogTime <= minion.LastAwareLogTime)
{
minion.MasterAgent = master;
}
}
}
}
}
}
_allAgentsList.RemoveAll(x => !(x.InstID != 0 && x.LastAwareLogTime - x.FirstAwareLogTime >= 0 && x.FirstAwareLogTime != 0 && x.LastAwareLogTime != long.MaxValue) && (x.Type != AgentItem.AgentType.Player && x.Type != AgentItem.AgentType.EnemyPlayer));
_agentData = new AgentData(_allAgentsList);
if (_agentData.GetAgentByType(AgentItem.AgentType.Player).Count == 0)
{
throw new InvalidDataException("Erroneous log, no player found");
}
}
private void CompletePlayers()
{
//Fix Disconnected players
List <AgentItem> playerAgentList = _agentData.GetAgentByType(AgentItem.AgentType.Player);
bool refresh = false;
foreach (AgentItem playerAgent in playerAgentList)
{
if (playerAgent.InstID == 0 || playerAgent.FirstAware == 0 || playerAgent.LastAware == long.MaxValue)
{
CombatItem tst = _combatItems.Find(x => x.SrcAgent == playerAgent.Agent);
if (tst == null)
{
tst = _combatItems.Find(x => x.DstAgent == playerAgent.Agent);
if (tst == null)
{
continue;
}
playerAgent.SetInstid(tst.DstInstid);
refresh = true;
}
else
{
playerAgent.SetInstid(tst.SrcInstid);
refresh = true;
}
playerAgent.OverrideAwareTimes(_logStartTime, _logEndTime);
}
bool skip = false;
var player = new Player(playerAgent, _fightData.Logic.Mode == FightLogic.ParseMode.Fractal, false);
foreach (Player p in _playerList)
{
if (p.Account == player.Account) // same player
{
if (p.Character == player.Character) // same character, can be fused
{
skip = true;
ulong agent = p.Agent;
foreach (CombatItem c in _combatItems)
{
if (player.Agent == c.DstAgent && c.IsStateChange.DstIsAgent())
{
c.OverrideDstAgent(agent);
}
if (player.Agent == c.SrcAgent && c.IsStateChange.SrcIsAgent())
{
c.OverrideSrcAgent(agent);
}
}
_agentData.SwapMasters(player.AgentItem, p.AgentItem);
p.AgentItem.OverrideAwareTimes(Math.Min(p.AgentItem.FirstAware, player.AgentItem.FirstAware), Math.Max(p.AgentItem.LastAware, player.AgentItem.LastAware));
break;
}
// different character in raid mode, discard it as it can't have any influence, otherwise add as a separate entity
else if (_fightData.Logic.Mode == FightLogic.ParseMode.Raid)
{
skip = true;
break;
}
}
}
if (!skip)
{
_playerList.Add(player);
}
}
if (_parserSettings.AnonymousPlayer)
{
for (int i = 0; i < _playerList.Count; i++)
{
_playerList[i].Anonymize(i + 1);
}
}
_playerList = _playerList.OrderBy(a => a.Group).ToList();
if (refresh)
{
_agentData.Refresh();
}
}
public override void SpecialParse(FightData fightData, AgentData agentData, List <CombatItem> combatData)
{
// Find target
Target target = Targets.Find(x => x.ID == (ushort)ParseEnum.TargetIDS.Deimos);
if (target == null)
{
throw new InvalidOperationException("Main target of the fight not found");
}
// enter combat
CombatItem enterCombat = combatData.FirstOrDefault(x => x.SrcInstid == target.InstID && x.IsStateChange == ParseEnum.StateChange.EnterCombat);
if (enterCombat != null)
{
fightData.FightStart = enterCombat.Time;
}
// Deimos gadgets
List <AgentItem> deimosGadgets = agentData.GetAgentByType(AgentItem.AgentType.Gadget).Where(x => x.Name.Contains("Deimos") && x.LastAware > target.LastAware).ToList();
if (deimosGadgets.Count > 0)
{
CombatItem targetable = combatData.LastOrDefault(x => x.IsStateChange == ParseEnum.StateChange.Targetable && x.Time > combatData.First().Time&& x.DstAgent > 0);
long firstAware = deimosGadgets.Max(x => x.FirstAware);
if (targetable != null)
{
firstAware = targetable.Time;
}
long oldAware = target.LastAware;
fightData.PhaseData.Add(firstAware >= oldAware ? firstAware : oldAware);
target.AgentItem.LastAware = deimosGadgets.Max(x => x.LastAware);
// get unique id for the fusion
ushort instID = 1;
Random rnd = new Random();
while (agentData.InstIDValues.Contains(instID))
{
instID = (ushort)rnd.Next(1, ushort.MaxValue);
}
target.AgentItem.InstID = instID;
agentData.Refresh();
// update combat data
HashSet <ulong> gadgetAgents = new HashSet <ulong>(deimosGadgets.Select(x => x.Agent));
HashSet <ulong> allAgents = new HashSet <ulong>(gadgetAgents);
allAgents.Add(target.Agent);
foreach (CombatItem c in combatData)
{
if (gadgetAgents.Contains(c.SrcAgent) && c.IsStateChange == ParseEnum.StateChange.MaxHealthUpdate)
{
continue;
}
if (allAgents.Contains(c.SrcAgent))
{
c.SrcInstid = target.InstID;
c.SrcAgent = target.Agent;
}
if (allAgents.Contains(c.DstAgent))
{
c.DstInstid = target.InstID;
c.DstAgent = target.Agent;
}
}
}
}
internal override void EIEvtcParse(ulong gw2Build, FightData fightData, AgentData agentData, List <CombatItem> combatData, IReadOnlyDictionary <uint, AbstractExtensionHandler> extensions)
{
// has breakbar state into
if (combatData.Any(x => x.IsStateChange == ArcDPSEnums.StateChange.BreakbarState))
{
var sacrificeList = combatData.Where(x => x.SkillID == MatthiasSacrifice && !x.IsExtension && (x.IsBuffRemove == ArcDPSEnums.BuffRemove.All || x.IsBuffApply())).ToList();
var sacrificeStartList = sacrificeList.Where(x => x.IsBuffRemove == ArcDPSEnums.BuffRemove.None).ToList();
var sacrificeEndList = sacrificeList.Where(x => x.IsBuffRemove == ArcDPSEnums.BuffRemove.All).ToList();
var copies = new List <CombatItem>();
for (int i = 0; i < sacrificeStartList.Count; i++)
{
//
long sacrificeStartTime = sacrificeStartList[i].Time;
long sacrificeEndTime = i < sacrificeEndList.Count ? sacrificeEndList[i].Time : fightData.FightEnd;
//
AgentItem sacrifice = agentData.GetAgentByType(AgentItem.AgentType.Player).FirstOrDefault(x => x == agentData.GetAgent(sacrificeStartList[i].DstAgent, sacrificeStartList[i].Time));
if (sacrifice == null)
{
continue;
}
AgentItem sacrificeCrystal = agentData.AddCustomNPCAgent(sacrificeStartTime, sacrificeEndTime + 100, "Sacrificed " + (i + 1) + " " + sacrifice.Name.Split('\0')[0], sacrifice.Spec, (int)ArcDPSEnums.TrashID.MatthiasSacrificeCrystal, false);
foreach (CombatItem cbt in combatData)
{
if (!sacrificeCrystal.InAwareTimes(cbt.Time))
{
continue;
}
bool skip = !(cbt.DstMatchesAgent(sacrifice, extensions) || cbt.SrcMatchesAgent(sacrifice, extensions));
if (skip)
{
continue;
}
// redirect damage events
if (cbt.IsDamage(extensions))
{
// only redirect incoming damage
if (cbt.DstMatchesAgent(sacrifice, extensions))
{
cbt.OverrideDstAgent(sacrificeCrystal.Agent);
}
}
// copy the rest
else
{
var copy = new CombatItem(cbt);
if (copy.DstMatchesAgent(sacrifice, extensions))
{
copy.OverrideDstAgent(sacrificeCrystal.Agent);
}
if (copy.SrcMatchesAgent(sacrifice, extensions))
{
copy.OverrideSrcAgent(sacrificeCrystal.Agent);
}
copies.Add(copy);
}
}
}
if (copies.Any())
{
combatData.AddRange(copies);
}
}
ComputeFightTargets(agentData, combatData, extensions);
foreach (AbstractSingleActor target in Targets)
{
if (target.ID == (int)ArcDPSEnums.TrashID.MatthiasSacrificeCrystal)
{
target.SetManualHealth(100000);
}
}
}
private void CompletePlayers()
{
//Fix Disconnected players
var playerAgentList = _agentData.GetAgentByType(AgentItem.AgentType.Player);
foreach (AgentItem playerAgent in playerAgentList)
{
if (playerAgent.InstID == 0)
{
CombatItem tst = _combatItems.Find(x => x.SrcAgent == playerAgent.Agent);
if (tst == null)
{
tst = _combatItems.Find(x => x.DstAgent == playerAgent.Agent);
if (tst == null)
{
continue;
}
playerAgent.InstID = tst.DstInstid;
}
else
{
playerAgent.InstID = tst.SrcInstid;
}
playerAgent.FirstAware = _fightData.FightStart;
playerAgent.LastAware = _fightData.FightEnd;
}
List <CombatItem> lp = _combatItems.Where(x => x.IsStateChange == ParseEnum.StateChange.Despawn && x.SrcInstid == playerAgent.InstID).ToList();
Player player = new Player(playerAgent, _fightData.Logic.Mode == FightLogic.ParseMode.Fractal);
bool skip = false;
foreach (Player p in _playerList)
{
if (p.Account == player.Account)//is this a copy of original?
{
skip = true;
}
}
if (skip)
{
continue;
}
if (lp.Count > 0)
{
//make all actions of other instances to original instid
foreach (AgentItem extra in _agentData.GetAgentByType(AgentItem.AgentType.NPC))
{
if (extra.Agent == playerAgent.Agent)
{
var extraLoginId = extra.InstID;
foreach (CombatItem c in _combatItems)
{
if (c.SrcInstid == extraLoginId)
{
c.SrcInstid = playerAgent.InstID;
}
if (c.DstInstid == extraLoginId)
{
c.DstInstid = playerAgent.InstID;
}
}
break;
}
}
}
_playerList.Add(player);
}
}
public override void SpecialParse(FightData fightData, AgentData agentData, List <CombatItem> combatData)
{
// Find target
Target target = Targets.Find(x => x.ID == (ushort)ParseEnum.TargetIDS.Deimos);
if (target == null)
{
throw new InvalidOperationException("Main target of the fight not found");
}
if (!target.Character.Contains("Deimos"))
{
target.OverrideName("Deimos");
}
// enter combat
CombatItem enterCombat = combatData.FirstOrDefault(x => x.SrcInstid == target.InstID && x.IsStateChange == ParseEnum.StateChange.EnterCombat);
if (enterCombat != null)
{
fightData.FightStart = enterCombat.Time;
}
// Remove deimos despawn events as they are useless and mess with combat replay
combatData.RemoveAll(x => x.IsStateChange == ParseEnum.StateChange.Despawn && x.SrcInstid == target.InstID && x.Time <= target.LastAware && x.Time >= target.FirstAware);
// Deimos gadgets
List <AgentItem> deimosGadgets = agentData.GetAgentByType(AgentItem.AgentType.Gadget).Where(x => x.Name.Contains("Deimos") && x.LastAware > target.LastAware).ToList();
CombatItem invulApp = combatData.FirstOrDefault(x => x.DstInstid == target.InstID && x.IsBuff != 0 && x.BuffDmg == 0 && x.Value > 0 && x.SkillID == 762);
CombatItem targetable = combatData.LastOrDefault(x => x.IsStateChange == ParseEnum.StateChange.Targetable && x.Time > combatData.First().Time&& x.DstAgent > 0);
if (invulApp != null && targetable != null)
{
HashSet <ulong> gadgetAgents = new HashSet <ulong>();
long firstAware = targetable.Time;
AgentItem targetAgent = agentData.GetAgentByInstID(targetable.SrcInstid, targetable.Time);
if (targetAgent != GeneralHelper.UnknownAgent)
{
try
{
string[] names = targetAgent.Name.Split('-');
if (ushort.TryParse(names[2], out ushort masterInstid))
{
CombatItem structDeimosDamageEvent = combatData.FirstOrDefault(x => x.Time >= firstAware && x.IFF == ParseEnum.IFF.Foe && x.DstInstid == masterInstid && x.IsStateChange == ParseEnum.StateChange.Normal && x.IsBuffRemove == ParseEnum.BuffRemove.None &&
((x.IsBuff == 1 && x.BuffDmg >= 0 && x.Value == 0) ||
(x.IsBuff == 0 && x.Value >= 0)));
if (structDeimosDamageEvent != null)
{
gadgetAgents.Add(structDeimosDamageEvent.DstAgent);
}
CombatItem armDeimosDamageEvent = combatData.FirstOrDefault(x => x.Time >= firstAware && (x.SkillID == 37980 || x.SkillID == 37982 || x.SkillID == 38046) && x.SrcAgent != 0 && x.SrcInstid != 0);
if (armDeimosDamageEvent != null)
{
gadgetAgents.Add(armDeimosDamageEvent.SrcAgent);
}
}
;
}
catch
{
// nothing to do
}
}
invulApp.Value = (int)(firstAware - invulApp.Time);
_specialSplit = (firstAware >= target.LastAware ? firstAware : target.LastAware);
target.AgentItem.LastAware = combatData.Last().Time;
SetUniqueID(target, gadgetAgents, agentData, combatData);
}
// legacy method
else if (deimosGadgets.Count > 0)
{
long firstAware = deimosGadgets.Max(x => x.FirstAware);
_specialSplit = (firstAware >= target.LastAware ? firstAware : target.LastAware);
target.AgentItem.LastAware = deimosGadgets.Max(x => x.LastAware);
HashSet <ulong> gadgetAgents = new HashSet <ulong>(deimosGadgets.Select(x => x.Agent));
SetUniqueID(target, gadgetAgents, agentData, combatData);
}
}
internal ParsedEvtcLog(int evtcVersion, FightData fightData, AgentData agentData, SkillData skillData,
List <CombatItem> combatItems, List <Player> playerList, IReadOnlyDictionary <uint, AbstractExtensionHandler> extensions, long evtcLogDuration, EvtcParserSettings parserSettings, ParserController operation)
{
FightData = fightData;
AgentData = agentData;
SkillData = skillData;
PlayerList = playerList;
PlayerAgents = new HashSet <AgentItem>(PlayerList.Select(x => x.AgentItem));
ParserSettings = parserSettings;
_operation = operation;
if (parserSettings.AnonymousPlayer)
{
operation.UpdateProgressWithCancellationCheck("Anonymous players");
for (int i = 0; i < PlayerList.Count; i++)
{
PlayerList[i].Anonymize(i + 1);
}
IReadOnlyList <AgentItem> allPlayerAgents = agentData.GetAgentByType(AgentItem.AgentType.Player);
int playerOffset = PlayerList.Count;
foreach (AgentItem playerAgent in allPlayerAgents)
{
if (!PlayerAgents.Contains(playerAgent))
{
string character = "Player " + playerOffset;
string account = "Account " + (playerOffset++);
playerAgent.OverrideName(character + "\0:" + account + "\01");
}
}
}
//
_operation.UpdateProgressWithCancellationCheck("Creating GW2EI Combat Events");
CombatData = new CombatData(combatItems, FightData, AgentData, SkillData, PlayerList, operation, extensions, evtcVersion);
if (parserSettings.AnonymousPlayer)
{
operation.UpdateProgressWithCancellationCheck("Anonymous guilds");
IReadOnlyList <AgentItem> allPlayerAgents = agentData.GetAgentByType(AgentItem.AgentType.Player);
foreach (AgentItem playerAgent in allPlayerAgents)
{
foreach (GuildEvent guildEvent in CombatData.GetGuildEvents(playerAgent))
{
guildEvent.Anonymize();
}
}
}
//
operation.UpdateProgressWithCancellationCheck("Checking CM");
FightData.SetEncounterMode(CombatData, AgentData);
operation.UpdateProgressWithCancellationCheck("Setting Fight Name");
FightData.SetFightName(CombatData, AgentData);
//
var friendlies = new List <AbstractSingleActor>();
friendlies.AddRange(PlayerList);
friendlies.AddRange(fightData.Logic.NonPlayerFriendlies);
Friendlies = friendlies;
FriendliesListBySpec = friendlies.GroupBy(x => x.Spec).ToDictionary(x => x.Key, x => x.ToList());
FriendlyAgents = new HashSet <AgentItem>(Friendlies.Select(x => x.AgentItem));
//
_operation.UpdateProgressWithCancellationCheck("Checking Success");
FightData.Logic.CheckSuccess(CombatData, AgentData, FightData, PlayerAgents);
if (FightData.FightDuration <= ParserSettings.TooShortLimit)
{
throw new TooShortException(FightData.FightDuration, ParserSettings.TooShortLimit);
}
if (ParserSettings.SkipFailedTries && !FightData.Success)
{
throw new SkipException();
}
_operation.UpdateProgressWithCancellationCheck("Creating GW2EI Log Meta Data");
LogData = new LogData(evtcVersion, CombatData, evtcLogDuration, playerList, extensions, operation);
//
_operation.UpdateProgressWithCancellationCheck("Creating Buff Container");
Buffs = new BuffsContainer(LogData.GW2Build, CombatData, operation);
_operation.UpdateProgressWithCancellationCheck("Creating Damage Modifier Container");
DamageModifiers = new DamageModifiersContainer(LogData.GW2Build, fightData.Logic.Mode, parserSettings);
_operation.UpdateProgressWithCancellationCheck("Creating Mechanic Data");
MechanicData = FightData.Logic.GetMechanicData();
_operation.UpdateProgressWithCancellationCheck("Creating General Statistics Container");
StatisticsHelper = new StatisticsHelper(CombatData, PlayerList, Buffs);
}
