private void Mainform_Shown(object sender, EventArgs e)
{
if (!PersistentState.Setup)
{
SetupForm setupForm = new SetupForm();
DialogResult result = setupForm.ShowDialog(this);
if (result != DialogResult.OK)
{
Application.Exit();
return;
}
PersistentState.Initialize(setupForm.Id, setupForm.Key, setupForm.BulkData);
}
_loader = new DynamoDbLoader();
_loader.StatusChanged += OtherThreadNotificationHandler;
_downloader = new DownloaderWorker();
_downloader.StatusChanged += OtherThreadNotificationHandler;
_mainThreadDelegate = MainThreadAction;
//lstCrashes.View = View.Details;
foreach (CrashReport crashReport in PersistentState.Database.GetAllCrashes())
{
_lstCrashReports.Add(crashReport);
}
_lstCrashReports.Sort(new CrashReportTimeStampFilter());
_bldCrashReports = new ObservableCollectionDisplay <CrashReport>(_lstCrashReports, c => new CrashReportView(c, _downloader))
{
Anchor = AnchorStyles.Bottom | AnchorStyles.Top | AnchorStyles.Right | AnchorStyles.Left,
Location = new Point(12, 69),
Size = new Size(863, 277),
};
tabReports.Controls.Add(_bldCrashReports);
string automation = PersistentState.Database.GetKey("autodownload_automation");
if (automation != null)
{
cboAutomation.SelectedIndex = int.Parse(automation);
}
UpdateDBDependantControls();
}
private void AddItemsToPresentedCollection(IList newItems)
{
foreach (var newItem in newItems)
{
_presentedItemsSource.Add((TViewModel)newItem);
}
}
public void CoverTargetListUpdate()
{
if (coverTargetCollection != null && coverTargetCollection?.Count != 0)
{
foreach (var pm in coverTargetCollection?.Where(x => !x.AllyIsValid()))
{
Logger.BeatrixLog("{0} is no longer a valid target. Removing them from the Cover Target List.", pm.SafeName());
coverTargetCollection?.Remove(pm);
}
}
foreach (var pm in PartyManager.VisibleMembers.Select(x => x.GameObject as BattleCharacter).Where(x => x != null &&
x.AllyIsValid() &&
!x.IsMe))
{
if (coverTargetCollection != null)
{
if (!coverTargetCollection.Contains(pm))
{
Logger.BeatrixLog("Adding {0} to the Cover Target List.", pm.SafeName());
}
if (!coverTargetCollection.Contains(pm))
{
coverTargetCollection?.Add(pm);
}
}
}
}
private void Assets_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
var asset = SelectedAsset;
_model.UnderlyingAsset = asset;
_model.Clear();
_options.Clear();
var options = asset.GetDerivatives(Connector);
// TODO remove
options = Connector.Securities.Where(s => s.Type == SecurityTypes.Option && s.Id.StartsWith("RI") && s.ExpiryDate > DateTime.Today);
foreach (var security in options)
{
// TODO remove
security.UnderlyingSecurityId = asset.Id;
_model.Add(security);
_options.Add(security);
}
ProcessPositions();
}
private void Check_Click(object sender, RoutedEventArgs e)
{
var terminal = this.SelectedTerminal;
if (terminal.SystemProcess.MainModule == null)
{
throw new InvalidOperationException("Неподходящий процесс для обработки.");
}
this.OkResult.SetVisibility(false);
_settingErrors.Clear();
var trader = new QuikTrader(terminal.SystemProcess.MainModule.FileName);
trader.Connected += () => this.GuiAsync(() =>
{
if (this.CheckDde.IsChecked == true)
{
trader.StartExport();
}
OnConnect(trader, null);
});
trader.ConnectionError += error => this.GuiSync(() => OnConnect(trader, error));
if (this.CheckDde.IsChecked == true)
{
trader.ProcessDataError += error => _settingErrors.Add(new SettingsError("Экспорт DDE. {0}".Put(error.Message), true));
}
trader.Connect();
}
public void NaturesMinneTargetListUpdate()
{
if (naturesMinneTargetCollection != null && naturesMinneTargetCollection?.Count != 0)
{
foreach (var pm in naturesMinneTargetCollection?.Where(x => !x.AllyIsValid()))
{
Logger.EdwardLog("{0} is no longer a valid target. Removing them from the NaturesMinne Target List.", pm.SafeName());
naturesMinneTargetCollection?.Remove(pm);
}
}
foreach (var pm in PartyManager.VisibleMembers.Select(x => x.GameObject as BattleCharacter).Where(x => x != null &&
x.AllyIsValid() &&
x.Type == GameObjectType.Pc &&
!x.IsMe))
{
if (naturesMinneTargetCollection != null)
{
if (!naturesMinneTargetCollection.Contains(pm))
{
Logger.EdwardLog("Adding {0} to the NaturesMinne Target List.", pm.SafeName());
}
if (!naturesMinneTargetCollection.Contains(pm))
{
naturesMinneTargetCollection?.Add(pm);
}
}
}
}
public void SmokeScreenTargetListUpdate()
{
if (smokeScreenTargetCollection != null && smokeScreenTargetCollection?.Count != 0)
{
foreach (var pm in smokeScreenTargetCollection?.Where(x => !x.AllyIsValid()))
{
Logger.ShadowLog("{0} is no longer a valid target. Removing them from the SmokeScreen Target List.", pm.SafeName());
smokeScreenTargetCollection?.Remove(pm);
}
}
foreach (var pm in PartyManager.VisibleMembers.Select(x => x.GameObject as BattleCharacter).Where(x => x != null &&
x.AllyIsValid() &&
x.Type == GameObjectType.Pc &&
x.IsTank() &&
!x.IsMe))
{
if (smokeScreenTargetCollection != null)
{
if (!smokeScreenTargetCollection.Contains(pm))
{
Logger.ShadowLog("Adding {0} to the SmokeScreen Target List.", pm.SafeName());
}
if (!smokeScreenTargetCollection.Contains(pm))
{
smokeScreenTargetCollection?.Add(pm);
}
}
}
}
public static ThreadSafeObservableCollection <TChild> CopyToChild <T, TChild>(this ThreadSafeObservableCollection <T> Enum) where TChild : class, new()
{
T _t = (T)Activator.CreateInstance(typeof(T));
TChild _tChild = (TChild)Activator.CreateInstance(typeof(TChild));
PropertyInfo[] selfPropertys = _t.GetType().GetProperties();
PropertyInfo[] childPropertys = _tChild.GetType().GetProperties();
ThreadSafeObservableCollection <TChild> ChildEnum = new ThreadSafeObservableCollection <TChild>();
foreach (T selfItem in Enum)
{
TChild childItem = new TChild();
foreach (var property in selfPropertys)
{
foreach (var childProperty in childPropertys)
{
if (property.Name == childProperty.Name)
{
property.SetValue(childItem, property.GetValue(selfItem, null), null);
}
}
}
ChildEnum.Add(childItem);
}
return(ChildEnum);
}
public void addTuioCursor(TuioCursor tcur)
{
Console.WriteLine("add cur " + tcur.CursorID + " (" + tcur.SessionID + ") " + tcur.X + " " + tcur.Y);
if (cursors.FirstOrDefault <TuioCursor>(tmp => tmp.CursorID == tcur.CursorID) == null)
{
cursors.Add(tcur);
}
}
public MainViewModel()
{
Posts = new ThreadSafeObservableCollection <Post>();
Notifications = new ThreadSafeObservableCollection <Notification>();
Circles = new ThreadSafeObservableCollection <KeyValuePair <string, string> >();
Circles.Add(new KeyValuePair <string, string>("Main", "1"));
InYourCircles = new ThreadSafeObservableCollection <KeyValuePair <string, string> >();
}
public void Test_PCB_CollectionChanged()
{
var collectionChanged = false;
var sut = new ThreadSafeObservableCollection<TestPCB>();
sut.CollectionChanged += (s, e) => collectionChanged = sut_CollectionChanged(e);
var item = new TestPCB();
sut.Add(item);
Assert.IsTrue(collectionChanged);
}
public static void Sort <TSource, TKey>(this ThreadSafeObservableCollection <TSource> source, Func <TSource, TKey> keySelector, bool isAZ)
{
if (isAZ)
{
List <TSource> sortedList = source.OrderBy(keySelector).ToList();
source.Clear();
foreach (var sortedItem in sortedList)
{
source.Add(sortedItem);
}
}
else
{
List <TSource> sortedList = source.OrderByDescending(keySelector).ToList();
source.Clear();
foreach (var sortedItem in sortedList)
{
source.Add(sortedItem);
}
}
}
/// <summary>
/// Load Installed Packages into Datagrid
/// </summary>
/// <param name="progress"></param>
private void LoadInstalledList(IProgress <int> progress, IEnumerable <HWGPackageModel> list)
{
var installedList = new ThreadSafeObservableCollection <HWGInstalledPackageModel>();
var installedAppList = GetInstalledAppList();
if (installedAppList == null)
{
RunOnMainThread(() =>
{
CreateInfoBarWithAction("Update Winget-Cli", "your Winget-cli is not supported please Update your winget-cli to version 1.0 or higher.", panelInstalled, Severity.Error, "Update", () =>
{
StartProcess(Consts.WingetRepository);
});
});
return;
}
var allPackages = list;
var allPackagesCount = allPackages.Count();
int currentItemIndex = 0;
foreach (var package in allPackages)
{
currentItemIndex += 1;
progress.Report((currentItemIndex * 100 / allPackagesCount));
foreach (var installedItem in installedAppList)
{
var installedApp = ParseInstalledApp(installedItem, package.PackageId);
if (installedApp.packageId != null && installedApp.version != null)
{
if (package.PackageId.Equals(installedApp.packageId, StringComparison.OrdinalIgnoreCase))
{
installedList.Add(new HWGInstalledPackageModel
{
Name = package.Name,
PackageId = package.PackageId,
Publisher = package.Publisher,
ProductCode = package.ProductCode,
YamlUri = package.YamlUri,
Version = installedApp.version,
AvailableVersion = installedApp.availableVersion
});
break;
}
}
}
}
RunOnMainThread(() =>
{
prgInstalled.Visibility = Visibility.Collapsed;
dataGridInstalled.ItemsSource = installedList;
});
}
/// <summary>
/// Добавить стратегии в таблицу.
/// </summary>
/// <param name="strategies">Стратегии.</param>
public void AddStrategies(IEnumerable <Strategy> strategies)
{
GuiDispatcher.GlobalDispatcher.AddAction(() =>
{
foreach (var strategy in strategies)
{
var item = new StrategyItem(strategy);
_map.Add(strategy, item);
_strategies.Add(item);
CreateColumns(strategy);
}
});
}
private void addPosts(int index = 0)
{
/*
* foreach (JToken post in list)
* posts.Add(new Post(post, 200, 10));
*/
App.UIDispatcher.BeginInvoke(() =>
{
posts.Add(new Post(list[index], 200, 10));
if (++index < list.Count)
{
addPosts(index);
}
});
}
public void LogSpell(string npcName, uint npcId, string spellName, uint spellId)
{
Application.Current.Dispatcher.InvokeAsync(() =>
{
if (spellLogCollection.Count > 300)
{
spellLogCollection.RemoveAt(0);
}
spellLogCollection.Add(new SpellInfo
{
NpcName = npcName,
NpcId = npcId,
SpellName = spellName,
SpellId = spellId
});
});
}
private void Assets_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
var asset = SelectedAsset;
_model.UnderlyingAsset = asset;
_model.Clear();
_options.Clear();
var options = asset.GetDerivatives(Connector);
foreach (var security in options)
{
_model.Add(security);
_options.Add(security);
}
ProcessPositions();
}
/// <summary>
/// Adds all albums to <see cref="AlbumCollection"/>.
/// </summary>
/// <remarks>This is still experimental, a lot of performance improvements are needed.
/// For instance, for each loop needs to be removed.
/// Maybe we can use direct database queries and fill the AlbumCollection with it?
/// </remarks>
public void AddAlbums()
{
foreach (var song in LibVM.TracksCollection.Elements)
{
Album alb = null;
if (!AlbumCollection.Any(t => t.AlbumName == song.Album && t.Artist == song.LeadArtist))
{
alb = new Album();
alb.AlbumName = song.Album;
alb.Artist = song.LeadArtist;
alb.AlbumArt = song.AttachedPicture;
AlbumCollection.Add(alb);
}
else
{
AlbumCollection.First(t => t.AlbumName == song.Album && t.Artist == song.LeadArtist).AlbumSongs.Add(song);
}
}
}
private void GetAssetsClick(object sender, RoutedEventArgs e)
{
_assetsList.Clear();
if (!App.FtpOperations.HaveSettings)
{
return;
}
var bw = new BackgroundWorker();
bw.DoWork += (o, args) => {
try {
var path = Path.Combine(Path.GetTempPath(), "AuroraAssetEditor.db");
if (!App.FtpOperations.DownloadContentDb(path))
{
return;
}
foreach (var title in AuroraDbManager.GetDbTitles(path))
{
_assetsList.Add(title);
}
args.Result = true;
}
catch (Exception ex) {
MainWindow.SaveError(ex);
args.Result = false;
}
};
bw.RunWorkerCompleted += (o, args) => {
_main.BusyIndicator.Visibility = Visibility.Collapsed;
if ((bool)args.Result)
{
Status.Text = "Finished grabbing FTP Assets information successfully...";
}
else
{
Status.Text = "There was an error, check error.log for more information...";
}
};
_main.BusyIndicator.Visibility = Visibility.Visible;
Status.Text = "Grabbing FTP Assets information...";
bw.RunWorkerAsync();
}
private void CheckClick(object sender, RoutedEventArgs e)
{
var terminal = SelectedTerminal;
if (terminal.SystemProcess.MainModule == null)
{
throw new InvalidOperationException(LocalizedStrings.InvalidProcess);
}
OkResult.SetVisibility(false);
_settingErrors.Clear();
var isDde = IsDde.IsChecked == true;
var connector = new QuikTrader(terminal.SystemProcess.MainModule.FileName)
{
IsDde = isDde
};
var checkDde = isDde && CheckDde.IsChecked == true;
connector.Connected += () => this.GuiAsync(() =>
{
if (checkDde)
{
connector.StartExport();
}
OnConnect(connector, null);
});
connector.ConnectionError += error => this.GuiSync(() => OnConnect(connector, error));
if (checkDde)
{
connector.ProcessDataError += error => _settingErrors.Add(new SettingsError(LocalizedStrings.Str3030Params.Put(error.Message), true));
}
connector.Connect();
}
public override void Init(bool setToDefaultValues = false)
{
// Set peaking equalizer effect with no bands
_eq = new PeakEQParameters();
_fxEq = Bass.ChannelSetFX(_handle, EffectType.PeakEQ, 0);
_eq.fQ = 0f;
_eq.fBandwidth = 2.5f;
_eq.lChannel = FXChannelFlags.All;
//init equalizer bands
Bands = new ThreadSafeObservableCollection <IEqualizerBand>();
var gainValues = !setToDefaultValues && EqualizerSettings != null ? EqualizerSettings.GainValues : null;
for (int i = 0; i < EqDefaultValues.Length; i++)
{
_eq.lBand = i;
_eq.fCenter = EqDefaultValues[i][0];
var res = Bass.FXSetParameters(_fxEq, _eq);
var band = new BassEqualizerBand(_fxEq, i, EqDefaultValues[i][0], EqDefaultValues[i][1], IsEnabled);
if (band == null)
{
continue;
}
if (gainValues != null && gainValues.TryGetValue(band.BandCaption, out float savedValue))
{
band.Gain = savedValue;
}
band.PropertyChanged += (sender, e) =>
{
if (e.PropertyName == "Gain")
{
SaveEqualizerSettings();
}
};
Bands.Add(band);
}
}
private ReadOnlyObservableCollection<TickerProviderViewModel> InitializeProviders()
{
var observableProviders = new ThreadSafeObservableCollection<TickerProviderViewModel>();
this.providerVMs = new ReadOnlyObservableCollection<TickerProviderViewModel>(observableProviders);
(this.providerVMs as INotifyCollectionChanged).CollectionChanged += (s, e) =>
{
if (e.NewItems.Count > 0 && SelectedProvider == null)
SelectedProvider = e.NewItems[0] as TickerProviderViewModel;
CanChangeProvider = providerVMs.Count > 1;
};
foreach (var arProvider in loadProvidersService.Load())
arProvider.AddCallback(x =>
{
if (x.Error == null)
observableProviders.Add(new TickerProviderViewModel(x.Result));
});
return this.providerVMs;
}
public void GoadTargetListUpdate()
{
if (goadTargetCollection != null && goadTargetCollection?.Count != 0)
{
foreach (var pm in goadTargetCollection?.Where(x => !x.AllyIsValid()))
{
Logger.KefkaLog("{0} is no longer a valid target. Removing them from the Goad Target List.", pm.SafeName());
goadTargetCollection?.Remove(pm);
}
}
foreach (var pm in PartyManager.VisibleMembers.Select(x => x.GameObject as BattleCharacter).Where(x => x != null &&
x.AllyIsValid() &&
x.Type == GameObjectType.Pc &&
(x.CurrentJob == ClassJobType.Marauder || x.CurrentJob == ClassJobType.Warrior ||
x.CurrentJob == ClassJobType.Gladiator || x.CurrentJob == ClassJobType.Paladin ||
x.CurrentJob == ClassJobType.Archer || x.CurrentJob == ClassJobType.Bard ||
x.CurrentJob == ClassJobType.Lancer || x.CurrentJob == ClassJobType.Dragoon ||
x.CurrentJob == ClassJobType.Pugilist || x.CurrentJob == ClassJobType.Monk ||
x.CurrentJob == ClassJobType.Rogue || x.CurrentJob == ClassJobType.Ninja ||
x.CurrentJob == ClassJobType.Machinist || x.CurrentJob == ClassJobType.DarkKnight) &&
!x.IsMe))
{
if (goadTargetCollection != null)
{
if (!goadTargetCollection.Contains(pm))
{
Logger.KefkaLog("Adding {0} to the Goad Target List.", pm.SafeName());
}
if (!goadTargetCollection.Contains(pm))
{
goadTargetCollection?.Add(pm);
}
}
}
}
private void InitConnector()
{
// subscribe on connection successfully event
Connector.Connected += () =>
{
// update gui labels
this.GuiAsync(() => ChangeConnectStatus(true));
};
// subscribe on disconnection event
Connector.Disconnected += () =>
{
// update gui labels
this.GuiAsync(() => ChangeConnectStatus(false));
};
// subscribe on connection error event
Connector.ConnectionError += error => this.GuiAsync(() =>
{
// update gui labels
ChangeConnectStatus(false);
MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2959);
});
// fill underlying asset's list
Connector.NewSecurity += security =>
{
if (security.Type == SecurityTypes.Future)
{
_assets.Add(security);
}
};
Connector.SecurityChanged += security =>
{
if (_model.UnderlyingAsset == security || _model.UnderlyingAsset.Id == security.UnderlyingSecurityId)
{
_isDirty = true;
}
};
// subscribing on tick prices and updating asset price
Connector.NewTrade += trade =>
{
if (_model.UnderlyingAsset == trade.Security || _model.UnderlyingAsset.Id == trade.Security.UnderlyingSecurityId)
{
_isDirty = true;
}
};
Connector.NewPosition += position => this.GuiAsync(() =>
{
var asset = SelectedAsset;
if (asset == null)
{
return;
}
var assetPos = position.Security == asset;
var newPos = position.Security.UnderlyingSecurityId == asset.Id;
if (!assetPos && !newPos)
{
return;
}
//if (assetPos)
// PosChart.AssetPosition = position;
//if (newPos)
// PosChart.Positions.Add(position);
RefreshChart();
});
Connector.PositionChanged += position => this.GuiAsync(() =>
{
if ((PosChart.UnderlyingAsset != null && PosChart.UnderlyingAsset == position.Security) || PosChart.Options.Contains(position.Security))
{
RefreshChart();
}
});
try
{
if (File.Exists(_settingsFile))
{
var ctx = new ContinueOnExceptionContext();
ctx.Error += ex => ex.LogError();
using (new Scope <ContinueOnExceptionContext> (ctx))
Connector.Load(new XmlSerializer <SettingsStorage>().Deserialize(_settingsFile));
}
}
catch
{
}
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
if (Connector != null && !(Connector is FakeConnector))
{
return;
}
PosChart.Positions.Clear();
PosChart.AssetPosition = null;
PosChart.Refresh(1, 1, default(DateTimeOffset), default(DateTimeOffset));
// create connection
Connector = new QuikTrader();
//_trader = new PlazaTrader { IsCGate = true };
//_trader.Tables.Add(_trader.TableRegistry.Volatility);
Portfolio.Portfolios = new PortfolioDataSource(Connector);
PosChart.MarketDataProvider = Connector;
PosChart.SecurityProvider = Connector;
// fill underlying asset's list
Connector.NewSecurity += security =>
{
if (security.Type == SecurityTypes.Future)
{
_assets.Add(security);
}
};
Connector.SecurityChanged += security =>
{
if ((PosChart.AssetPosition != null && PosChart.AssetPosition.Security == security) || PosChart.Positions.Cache.Select(p => p.Security).Contains(security))
{
_isDirty = true;
}
};
// subscribing on tick prices and updating asset price
Connector.NewTrade += trade =>
{
var assetPos = PosChart.AssetPosition;
if (assetPos != null && trade.Security == assetPos.Security)
{
_isDirty = true;
}
};
Connector.NewPosition += position => this.GuiAsync(() =>
{
var asset = SelectedAsset;
if (asset == null)
{
return;
}
var assetPos = position.Security == asset;
var newPos = position.Security.UnderlyingSecurityId == asset.Id;
if (!assetPos && !newPos)
{
return;
}
if (assetPos)
{
PosChart.AssetPosition = position;
}
if (newPos)
{
PosChart.Positions.Add(position);
}
RefreshChart();
});
Connector.PositionChanged += position => this.GuiAsync(() =>
{
if ((PosChart.AssetPosition != null && PosChart.AssetPosition == position) || PosChart.Positions.Cache.Contains(position))
{
RefreshChart();
}
});
Connector.Connect();
}
private void InitConnector()
{
// fill underlying asset's list
Connector.NewSecurity += security =>
{
if (security.Type == SecurityTypes.Future)
{
_assets.Add(security);
}
};
Connector.SecurityChanged += security =>
{
if ((PosChart.AssetPosition != null && PosChart.AssetPosition.Security == security) || PosChart.Positions.Cache.Select(p => p.Security).Contains(security))
{
_isDirty = true;
}
};
// subscribing on tick prices and updating asset price
Connector.NewTrade += trade =>
{
var assetPos = PosChart.AssetPosition;
if (assetPos != null && trade.Security == assetPos.Security)
{
_isDirty = true;
}
};
Connector.NewPosition += position => this.GuiAsync(() =>
{
var asset = SelectedAsset;
if (asset == null)
{
return;
}
var assetPos = position.Security == asset;
var newPos = position.Security.UnderlyingSecurityId == asset.Id;
if (!assetPos && !newPos)
{
return;
}
if (assetPos)
{
PosChart.AssetPosition = position;
}
if (newPos)
{
PosChart.Positions.Add(position);
}
RefreshChart();
});
Connector.PositionChanged += position => this.GuiAsync(() =>
{
if ((PosChart.AssetPosition != null && PosChart.AssetPosition == position) || PosChart.Positions.Cache.Contains(position))
{
RefreshChart();
}
});
try
{
if (File.Exists(_settingsFile))
{
Connector.Load(new XmlSerializer <SettingsStorage>().Deserialize(_settingsFile));
}
}
catch
{
}
}
private void AddStrategy(string name, Strategy strategy)
{
_itemsTs.Add(new StrategyItem(name, strategy));
MainWindow.Instance.LogManager.Sources.Add(strategy);
strategy.Start();
}
private void FillSkillLog(ThreadSafeObservableCollection<AggregatedSkillResult> skillLog,
IEnumerable<AggregatedSkillResult> results)
{
foreach (var result in results)
skillLog.Add(result);
}
public static void ToTeraDpsApi(SDespawnNpc despawnNpc, DamageTracker damageTracker, EntityTracker entityTracker, TeraData teraData)
{
if (!despawnNpc.Dead)
{
return;
}
var entity = entityTracker.GetOrPlaceholder(despawnNpc.Npc) as NpcEntity;
if (!(entity?.Info.Boss ?? false))
{
return;
}
if (!SettingsHelper.Instance.Settings.ExcelExport &&
(string.IsNullOrEmpty(SettingsHelper.Instance.Settings.TeraDpsToken) ||
string.IsNullOrEmpty(SettingsHelper.Instance.Settings.TeraDpsUser) ||
!SettingsHelper.Instance.Settings.SiteExport)
)
{
return;
}
var abnormals = damageTracker.Abnormals;
bool timedEncounter = false;
//Nightmare desolarus
if (entity.Info.HuntingZoneId == 759 && entity.Info.TemplateId == 1003)
{
timedEncounter = true;
}
var firstHit = damageTracker.StatsByUser.SelectMany(x => x.SkillLog).Where(x => x.Target == entity).Min(x => x.Time as DateTime?) ?? new DateTime(0);
var lastHit = damageTracker.StatsByUser.SelectMany(x => x.SkillLog).Where(x => x.Target == entity).Max(x => x.Time as DateTime?) ?? new DateTime(0);
var firstTick = firstHit.Ticks;
var lastTick = lastHit.Ticks;
var interval = lastTick - firstTick;
var seconds = interval / TimeSpan.TicksPerSecond;
if (seconds == 0)
{
return;
}
long totaldamage;
if (timedEncounter)
{
totaldamage =
damageTracker.StatsByUser.SelectMany(x => x.SkillLog)
.Where(x => x.Time >= firstHit && x.Time <= lastHit)
.Sum(x => x.Damage);
}
else
{
totaldamage =
damageTracker.StatsByUser.SelectMany(x => x.SkillLog)
.Where(x => x.Target == entity)
.Sum(x => x.Damage);
}
var partyDps = TimeSpan.TicksPerSecond * totaldamage / interval;
var teradpsData = new EncounterBase
{
areaId = entity.Info.HuntingZoneId + "",
bossId = entity.Info.TemplateId + "",
fightDuration = seconds + "",
partyDps = partyDps + ""
};
foreach (var debuff in abnormals.Get(entity))
{
long percentage = debuff.Value.Duration(firstTick, lastTick) * 100 / interval;
if (percentage == 0)
{
continue;
}
teradpsData.debuffUptime.Add(new KeyValuePair <string, string>(
debuff.Key.Id + "", percentage + ""
));
}
foreach (var user in damageTracker.StatsByUser)
{
var filteredSkillog = timedEncounter
? user.SkillLog.Where(x => x.Time >= firstHit && x.Time <= lastHit).ToList()
: user.SkillLog.Where(x => x.Target == entity).ToList();
long damage = filteredSkillog.Sum(x => x.Damage);
if (damage <= 0)
{
continue;
}
var teradpsUser = new Members();
teradpsUser.playerTotalDamage = damage + "";
var buffs = abnormals.Get(user.Player);
teradpsUser.playerClass = user.Class.ToString();
teradpsUser.playerName = user.Name;
teradpsUser.playerServer = SettingsHelper.Instance.BasicTeraData.Servers.GetServerName(user.Player.ServerId);
teradpsUser.playerAverageCritRate = Math.Round(100 * (double)filteredSkillog.Count(x => x.IsCritical && x.Damage > 0) / filteredSkillog.Count(x => x.Damage > 0), 1) + "";
teradpsUser.healCrit = user.Player.IsHealer ? Math.Round(100 * (double)filteredSkillog.Count(x => x.IsCritical && x.Heal > 0) / filteredSkillog.Count(x => x.Heal > 0), 1) + "" : null;
teradpsUser.playerDps = TimeSpan.TicksPerSecond * damage / interval + "";
teradpsUser.playerTotalDamagePercentage = damage * 100 / totaldamage + "";
var death = buffs.Death;
teradpsUser.playerDeaths = death.Count(firstTick, lastTick) + "";
teradpsUser.playerDeathDuration = death.Duration(firstTick, lastTick) / TimeSpan.TicksPerSecond + "";
var aggro = buffs.Aggro(entity);
teradpsUser.aggro = 100 * aggro.Duration(firstTick, lastTick) / interval + "";
foreach (var buff in buffs.Times)
{
long percentage = (buff.Value.Duration(firstTick, lastTick) * 100 / interval);
if (percentage == 0)
{
continue;
}
teradpsUser.buffUptime.Add(new KeyValuePair <string, string>(
buff.Key.Id + "", percentage + ""
));
}
var aggregated = new List <AggregatedSkillResult>();
var collection = new ThreadSafeObservableCollection <SkillResult>();
foreach (var skill in filteredSkillog)
{
collection.Add(skill);
if (aggregated.All(asr => !skill.IsSameSkillAs(asr)))
{
aggregated.Add(new AggregatedSkillResult(skill.SkillShortName, skill.IsHeal, AggregationType.Name, collection));
}
}
foreach (var skill in aggregated)
{
var skillLog = new SkillLog();
var skilldamage = skill.Damage;
if (skilldamage == 0)
{
continue;
}
skillLog.skillAverageCrit = skill.AverageCrit + "";
skillLog.skillAverageWhite = skill.AverageWhite + "";
skillLog.skillCritRate = Math.Round(skill.CritRate * 100, 1) + "";
skillLog.skillDamagePercent = Math.Round(skill.DamagePercent * 100, 1) + "";
skillLog.skillHighestCrit = skill.HighestCrit + "";
skillLog.skillHits = skill.Hits + "";
skillLog.skillId = teraData.SkillDatabase.GetSkillByPetName(skill.NpcInfo?.Name, user.Player.RaceGenderClass)?.Id.ToString() ?? skill.SkillId.ToString();
skillLog.skillLowestCrit = skill.LowestCrit + "";
skillLog.skillTotalDamage = skilldamage + "";
teradpsUser.skillLog.Add(skillLog);
}
teradpsData.members.Add(teradpsUser);
}
if (SettingsHelper.Instance.Settings.ExcelExport)
{
Task.Run(() => ExcelExport.ExcelSave(teradpsData, teraData));
}
if (string.IsNullOrEmpty(SettingsHelper.Instance.Settings.TeraDpsToken) || string.IsNullOrEmpty(SettingsHelper.Instance.Settings.TeraDpsUser) || !SettingsHelper.Instance.Settings.SiteExport)
{
return;
}
/*
* Validation, without that, the server cpu will be burning \o
*/
var areaId = int.Parse(teradpsData.areaId);
if (
areaId != 886 &&
areaId != 467 &&
areaId != 767 &&
areaId != 768 &&
areaId != 470 &&
areaId != 468
)
{
return;
}
if (int.Parse(teradpsData.partyDps) < 2000000 && areaId != 468)
{
return;
}
string json = JsonConvert.SerializeObject(teradpsData, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
Task.Run(() => Send(entity, json, 3));
}
private void AddSecurity(Security security)
{
_itemsSource.Add(security);
}
private void ChatControl_OnLoaded()
{
var client = Client;
client.AuthorAdded += OnAuthorAdded;
client.AuthorDeleted += OnAuthorDeleted;
client.JoinAccepted += OnJoinAccepted;
client.JoinRejected += OnJoinRejected;
client.JoinSended += OnJoinSended;
client.LoggedIn += OnLoggedIn;
client.LoggedOut += OnLoggedOut;
client.MessageCreated += OnMessageCreated;
client.MessageUpdated += OnMessageUpdated;
client.MessageDeleted += OnMessageDeleted;
client.RoomCreated += OnRoomCreated;
client.RoomDeleted += OnRoomDeleted;
client.RoomUpdated += OnRoomUpdated;
var cmdSvc = ConfigManager.GetService <IStudioCommandService>();
cmdSvc.Register <LoggedInCommand>(this, false, cmd =>
{
IsEnabled = true;
var rooms = _chatRooms.ToDictionary(i => i.Room, i => i);
foreach (var room in client.AllRooms)
{
var item = rooms.TryGetValue(room);
if (item != null)
{
rooms.Remove(room);
continue;
}
item = new RoomItem(room);
item.Users.AddRange(client.GetAuthors(room));
_chatRooms.Add(item);
}
_chatRooms.RemoveRange(rooms.Values);
UpdateTitle();
});
cmdSvc.Register <LoggedOutCommand>(this, false, cmd =>
{
IsEnabled = false;
UpdateTitle();
});
IsEnabled = ConfigManager.GetService <AuthenticationClient>().IsLoggedIn;
UpdateTitle();
if (IsEnabled)
{
return;
}
var res = new MessageBoxBuilder()
.Owner(this)
.Text(LocalizedStrings.Str3207)
.Warning()
.YesNo()
.Show();
if (res == MessageBoxResult.Yes)
{
cmdSvc.Process(this, new LogInCommand());
}
}
