private void DeleteDeck(Deck deck, bool saveAndUpdate = true)
{
if (deck == null)
{
return;
}
if (Equals(DeckList.Instance.ActiveDeck, deck))
{
SelectDeck(null, true);
}
DeckStats deckStats;
if (DeckStatsList.Instance.DeckStats.TryGetValue(deck.DeckId, out deckStats))
{
if (deckStats.Games.Any())
{
if (Config.Instance.KeepStatsWhenDeletingDeck)
{
var defaultDeck = DefaultDeckStats.Instance.GetDeckStats(deck.Class);
defaultDeck?.Games.AddRange(deckStats.Games);
DefaultDeckStats.Save();
Log.Info($"Moved deckstats for deck {deck.Name} to default stats");
}
}
DeckStatsList.Instance.DeckStats.TryRemove(deckStats.DeckId, out deckStats);
if (saveAndUpdate)
{
DeckStatsList.Save();
}
Log.Info("Removed deckstats from deck: " + deck.Name);
}
DeckList.Instance.Decks.Remove(deck);
if (saveAndUpdate)
{
DeckList.Save();
DeckPickerList.UpdateDecks();
DeckPickerList.UpdateArchivedClassVisibility();
}
Log.Info("Deleted deck: " + deck.Name);
}
private static async Task <bool> TryUpload(string[] logLines, GameMetaData gameMetaData, GameStats game, bool submitFailure)
{
try
{
game?.HsReplay.UploadTry();
Influx.OnGameUpload(game?.HsReplay.UploadTries ?? 1);
var lines = logLines.SkipWhile(x => !x.Contains("CREATE_GAME")).ToArray();
var metaData = UploadMetaDataGenerator.Generate(lines, gameMetaData, game);
Log.Info("Creating upload request...");
var uploadRequest = await ApiWrapper.CreateUploadRequest(metaData);
Log.Info("Upload Id: " + uploadRequest.ShortId);
await ApiWrapper.UploadLog(uploadRequest, lines);
Log.Info("Upload complete");
if (game != null)
{
game.HsReplay.UploadId = uploadRequest.ShortId;
game.HsReplay.ReplayUrl = uploadRequest.ReplayUrl;
if (DefaultDeckStats.Instance.DeckStats.Any(x => x.DeckId == game.DeckId))
{
DefaultDeckStats.Save();
}
else
{
DeckStatsList.Save();
}
}
return(true);
}
catch (WebException ex)
{
Log.Error(ex);
if (submitFailure)
{
Influx.OnGameUploadFailed(ex.Status);
}
return(false);
}
}
private async void DeleteGames(DataGrid dataGrid, bool overall)
{
MetroWindow window;
if (Config.Instance.StatsInWindow)
{
window = Core.Windows.StatsWindow;
}
else
{
window = Helper.MainWindow;
}
var count = dataGrid.SelectedItems.Count;
if (count == 1)
{
var selectedGame = dataGrid.SelectedItem as GameStats;
if (selectedGame == null)
{
return;
}
if (await window.ShowDeleteGameStatsMessage(selectedGame) != MessageDialogResult.Affirmative)
{
return;
}
if (!overall)
{
if (_deck.DeckStats.Games.Contains(selectedGame))
{
selectedGame.DeleteGameFile();
_deck.DeckStats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game " + selectedGame + "(overall=" + overall + ")", "DeckStatsControl");
DeckStatsList.Save();
}
}
else
{
var deck = DeckList.Instance.Decks.FirstOrDefault(d => d.DeckStats.Games.Contains(selectedGame));
if (deck != null)
{
if (deck.DeckStats.Games.Contains(selectedGame))
{
selectedGame.DeleteGameFile();
deck.DeckStats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game " + selectedGame + "(overall=" + overall + ")", "DeckStatsControl");
DefaultDeckStats.Save();
}
}
else
{
var deckstats = DefaultDeckStats.Instance.DeckStats.FirstOrDefault(ds => ds.Games.Contains(selectedGame));
if (deckstats != null)
{
selectedGame.DeleteGameFile();
deckstats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game " + selectedGame + "(overall=" + overall + ")", "DeckStatsControl");
DefaultDeckStats.Save();
}
}
}
if (HearthStatsAPI.IsLoggedIn && selectedGame.HasHearthStatsId && await Core.MainWindow.ShowCheckHearthStatsMatchDeletionDialog())
{
HearthStatsManager.DeleteMatchesAsync(new List <GameStats> {
selectedGame
});
}
//Core.MainWindow.DeckPickerList.Items.Refresh();
Core.MainWindow.DeckPickerList.UpdateDecks();
Refresh();
}
else if (count > 1)
{
if (await window.ShowDeleteMultipleGameStatsMessage(count) != MessageDialogResult.Affirmative)
{
return;
}
var selectedGames = dataGrid.SelectedItems.Cast <GameStats>().Where(g => g != null).ToList();
foreach (var selectedGame in selectedGames)
{
if (!overall)
{
if (_deck.DeckStats.Games.Contains(selectedGame))
{
selectedGame.DeleteGameFile();
_deck.DeckStats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game " + selectedGame + "(overall=" + overall + ")", "DeckStatsControl");
}
}
else
{
var deck = DeckList.Instance.Decks.FirstOrDefault(d => d.DeckStats.Games.Contains(selectedGame));
if (deck != null)
{
if (deck.DeckStats.Games.Contains(selectedGame))
{
selectedGame.DeleteGameFile();
deck.DeckStats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game " + selectedGame + "(overall=" + overall + ")", "DeckStatsControl");
}
}
else
{
var deckstats = DefaultDeckStats.Instance.DeckStats.FirstOrDefault(ds => ds.Games.Contains(selectedGame));
if (deckstats != null)
{
selectedGame.DeleteGameFile();
deckstats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game " + selectedGame + "(overall=" + overall + ")", "DeckStatsControl");
}
}
}
}
if (HearthStatsAPI.IsLoggedIn && selectedGames.Any(g => g.HasHearthStatsId) &&
await Core.MainWindow.ShowCheckHearthStatsMatchDeletionDialog())
{
HearthStatsManager.DeleteMatchesAsync(selectedGames);
}
DeckStatsList.Save();
DefaultDeckStats.Save();
Logger.WriteLine("Deleted " + count + " games", "DeckStatsControl");
Core.MainWindow.DeckPickerList.UpdateDecks();
Refresh();
}
}
private void MoveGameToOtherDeck(List <GameStats> selectedGames)
{
if (selectedGames == null)
{
return;
}
var heroes = new Dictionary <string, int>();
foreach (var game in selectedGames)
{
if (!heroes.ContainsKey(game.PlayerHero))
{
heroes.Add(game.PlayerHero, 0);
}
heroes[game.PlayerHero]++;
}
var heroPlayed = heroes.Any() ? heroes.OrderByDescending(x => x.Value).First().Key : "Any";
var possibleTargets = DeckList.Instance.Decks.Where(d => d.Class == heroPlayed || heroPlayed == "Any");
var dialog = new MoveGameDialog(possibleTargets);
if (Config.Instance.StatsInWindow)
{
dialog.Owner = Core.Windows.StatsWindow;
}
else
{
dialog.Owner = Helper.MainWindow;
}
dialog.ShowDialog();
var selectedDeck = dialog.SelectedDeck;
if (selectedDeck == null)
{
return;
}
foreach (var game in selectedGames)
{
var defaultDeck = DefaultDeckStats.Instance.DeckStats.FirstOrDefault(ds => ds.Games.Contains(game));
if (defaultDeck != null)
{
defaultDeck.Games.Remove(game);
DefaultDeckStats.Save();
}
else
{
var deck = DeckList.Instance.Decks.FirstOrDefault(d => game.DeckId == d.DeckId);
if (deck != null)
{
deck.DeckStats.Games.Remove(game);
}
}
game.PlayerDeckVersion = dialog.SelectedVersion;
game.HearthStatsDeckVersionId = selectedDeck.GetVersion(dialog.SelectedVersion).HearthStatsDeckVersionId;
game.DeckId = selectedDeck.DeckId;
game.DeckName = selectedDeck.Name;
selectedDeck.DeckStats.Games.Add(game);
if (HearthStatsAPI.IsLoggedIn && Config.Instance.HearthStatsAutoUploadNewGames)
{
HearthStatsManager.MoveMatchAsync(game, selectedDeck, background: true);
}
}
DeckStatsList.Save();
DeckList.Save();
Refresh();
Core.MainWindow.DeckPickerList.UpdateDecks();
}
private void SaveAndUpdateStats()
{
if (RecordCurrentGameMode)
{
if (Config.Instance.ShowNoteDialogAfterGame && Config.Instance.NoteDialogDelayed && !_showedNoteDialog)
{
_showedNoteDialog = true;
new NoteDialog(_game.CurrentGameStats);
}
if (_game.CurrentGameStats != null)
{
_game.CurrentGameStats.Turns = _game.GetTurnNumber();
if (Config.Instance.DiscardZeroTurnGame && _game.CurrentGameStats.Turns < 1)
{
Log.Info("Game has 0 turns, discarded. (DiscardZeroTurnGame)");
return;
}
if (_game.CurrentGameStats.GameMode != _game.CurrentGameMode)
{
_game.CurrentGameStats.GameMode = _game.CurrentGameMode;
Log.Info("Set CurrentGameStats.GameMode to " + _game.CurrentGameMode);
}
if (_game.CurrentGameStats.GameMode == Arena)
{
ArenaStats.Instance.UpdateArenaStats();
ArenaStats.Instance.UpdateArenaRuns();
ArenaStats.Instance.UpdateArenaStatsHighlights();
}
else
{
ConstructedStats.Instance.UpdateConstructedStats();
}
}
if (_assignedDeck == null)
{
Log.Info("Saving DefaultDeckStats");
DefaultDeckStats.Save();
}
else
{
_assignedDeck.StatsUpdated();
Log.Info("Saving DeckStats");
DeckStatsList.Save();
}
LastGames.Instance.Add(_game.CurrentGameStats);
LastGames.Save();
}
else if (_assignedDeck != null && _assignedDeck.DeckStats.Games.Contains(_game.CurrentGameStats))
{
//game was not supposed to be recorded, remove from deck again.
_assignedDeck.DeckStats.Games.Remove(_game.CurrentGameStats);
Log.Info($"Gamemode {_game.CurrentGameMode} is not supposed to be saved. Removed game from {_assignedDeck}.");
}
else if (_assignedDeck == null)
{
var defaultDeck = DefaultDeckStats.Instance.GetDeckStats(_game.Player.Class);
if (defaultDeck != null)
{
defaultDeck.Games.Remove(_game.CurrentGameStats);
Log.Info($"Gamemode {_game.CurrentGameMode} is not supposed to be saved. Removed game from default {_game.Player.Class}.");
}
}
}
public MainWindow()
{
// Set working directory to path of executable
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
InitializeComponent();
Trace.Listeners.Add(new TextBoxTraceListener(Options.TextBoxLog));
EnableMenuItems(false);
try
{
if (File.Exists("Updater_new.exe"))
{
if (File.Exists("Updater.exe"))
{
File.Delete("Updater.exe");
}
File.Move("Updater_new.exe", "Updater.exe");
}
}
catch
{
Logger.WriteLine("Error updating updater");
}
Helper.MainWindow = this;
/*_configPath =*/
Config.Load();
HsLogReader.Create();
var configVersion = string.IsNullOrEmpty(Config.Instance.CreatedByVersion)
? null
: new Version(Config.Instance.CreatedByVersion);
Version currentVersion;
if (Config.Instance.CheckForUpdates)
{
currentVersion = Helper.CheckForUpdates(out NewVersion);
_lastUpdateCheck = DateTime.Now;
}
else
{
currentVersion = Helper.GetCurrentVersion();
}
var versionString = string.Empty;
if (currentVersion != null)
{
versionString = string.Format("{0}.{1}.{2}", currentVersion.Major, currentVersion.Minor, currentVersion.Build);
Help.TxtblockVersion.Text = "Version: " + versionString;
// Assign current version to the config instance so that it will be saved when the config
// is rewritten to disk, thereby telling us what version of the application created it
Config.Instance.CreatedByVersion = currentVersion.ToString();
}
ConvertLegacyConfig(currentVersion, configVersion);
if (Config.Instance.SelectedTags.Count == 0)
{
Config.Instance.SelectedTags.Add("All");
}
_foundHsDirectory = FindHearthstoneDir();
if (_foundHsDirectory)
{
_updatedLogConfig = UpdateLogConfigFile();
}
//hearthstone, loads db etc - needs to be loaded before playerdecks, since cards are only saved as ids now
Game.Reset();
_decksPath = Config.Instance.DataDir + "PlayerDecks.xml";
SetupDeckListFile();
try
{
DeckList = XmlManager <Decks> .Load(_decksPath);
}
catch (Exception e)
{
MessageBox.Show(
e.Message + "\n\n" + e.InnerException +
"\n\n If you don't know how to fix this, please delete " + _decksPath +
" (this will cause you to lose your decks).",
"Error loading PlayerDecks.xml");
Application.Current.Shutdown();
}
foreach (var deck in DeckList.DecksList)
{
DeckPickerList.AddDeck(deck);
}
SetupDefaultDeckStatsFile();
DefaultDeckStats.Load();
SetupDeckStatsFile();
DeckStatsList.Load();
_notifyIcon = new NotifyIcon {
Icon = new Icon(@"Images/HearthstoneDeckTracker16.ico"), Visible = true, ContextMenu = new ContextMenu(), Text = "Hearthstone Deck Tracker v" + versionString
};
_notifyIcon.ContextMenu.MenuItems.Add("Use no deck", (sender, args) => DeselectDeck());
_notifyIcon.ContextMenu.MenuItems.Add(new MenuItem("Autoselect deck")
{
MenuItems =
{
new MenuItem("On",
(sender, args) =>
AutoDeckDetection(true)),
new MenuItem("Off",
(sender, args) =>
AutoDeckDetection(false))
}
}); _notifyIcon.ContextMenu.MenuItems.Add(new MenuItem("Class cards first")
{
MenuItems =
{
new MenuItem("Yes",
(sender, args) =>
SortClassCardsFirst(true)),
new MenuItem("No",
(sender, args) =>
SortClassCardsFirst(false))
}
});
_notifyIcon.ContextMenu.MenuItems.Add("Show", (sender, args) => ActivateWindow());
_notifyIcon.ContextMenu.MenuItems.Add("Exit", (sender, args) => Close());
_notifyIcon.MouseClick += (sender, args) => { if (args.Button == MouseButtons.Left)
{
ActivateWindow();
}
};
//create overlay
Overlay = new OverlayWindow {
Topmost = true
};
PlayerWindow = new PlayerWindow(Config.Instance, Game.IsUsingPremade ? Game.PlayerDeck : Game.PlayerDrawn);
OpponentWindow = new OpponentWindow(Config.Instance, Game.OpponentCards);
TimerWindow = new TimerWindow(Config.Instance);
StatsWindow = new StatsWindow();
if (Config.Instance.PlayerWindowOnStart)
{
PlayerWindow.Show();
}
if (Config.Instance.OpponentWindowOnStart)
{
OpponentWindow.Show();
}
if (Config.Instance.TimerWindowOnStartup)
{
TimerWindow.Show();
}
if (!DeckList.AllTags.Contains("All"))
{
DeckList.AllTags.Add("All");
WriteDecks();
}
if (!DeckList.AllTags.Contains("Favorite"))
{
if (DeckList.AllTags.Count > 1)
{
DeckList.AllTags.Insert(1, "Favorite");
}
else
{
DeckList.AllTags.Add("Favorite");
}
WriteDecks();
}
if (!DeckList.AllTags.Contains("Arena"))
{
DeckList.AllTags.Add("Arena");
WriteDecks();
}
if (!DeckList.AllTags.Contains("Constructed"))
{
DeckList.AllTags.Add("Constructed");
WriteDecks();
}
if (!DeckList.AllTags.Contains("None"))
{
DeckList.AllTags.Add("None");
WriteDecks();
}
Options.ComboboxAccent.ItemsSource = ThemeManager.Accents;
Options.ComboboxTheme.ItemsSource = ThemeManager.AppThemes;
Options.ComboboxLanguages.ItemsSource = Helper.LanguageDict.Keys;
Options.ComboboxKeyPressGameStart.ItemsSource = EventKeys;
Options.ComboboxKeyPressGameEnd.ItemsSource = EventKeys;
LoadConfig();
FillElementSorters();
//this has to happen before reader starts
var lastDeck = DeckList.DecksList.FirstOrDefault(d => d.Name == Config.Instance.LastDeck);
DeckPickerList.SelectDeck(lastDeck);
TurnTimer.Create(90);
SortFilterDecksFlyout.HideStuffToCreateNewTag();
TagControlEdit.OperationSwitch.Visibility = Visibility.Collapsed;
TagControlEdit.PnlSortDecks.Visibility = Visibility.Collapsed;
UpdateDbListView();
_doUpdate = _foundHsDirectory;
UpdateOverlayAsync();
_initialized = true;
Options.MainWindowInitialized();
DeckPickerList.UpdateList();
if (lastDeck != null)
{
DeckPickerList.SelectDeck(lastDeck);
UpdateDeckList(lastDeck);
UseDeck(lastDeck);
}
if (_foundHsDirectory)
{
HsLogReader.Instance.Start();
}
Helper.SortCardCollection(ListViewDeck.Items, Config.Instance.CardSortingClassFirst);
DeckPickerList.SortDecks();
// Set Language
var culture = Config.Instance.SelectedLanguage.Insert(2, "-");
WPFLocalizeExtension.Engine.LocalizeDictionary.Instance.Culture = System.Globalization.CultureInfo.GetCultureInfo(culture);
if (!Directory.Exists(culture))
{
var langPath = Path.Combine("Lang", culture);
if (Directory.Exists(langPath))
{
Helper.CopyFolder(langPath, culture);
_showRestartMessage = true;
}
}
}
private async void DeleteGames(DataGrid dataGrid, bool overall)
{
MetroWindow window;
if (Config.Instance.StatsInWindow)
{
window = Helper.MainWindow.StatsWindow;
}
else
{
window = Helper.MainWindow;
}
var count = dataGrid.SelectedItems.Count;
if (count == 1)
{
var selectedGame = dataGrid.SelectedItem as GameStats;
if (selectedGame == null)
{
return;
}
if (await window.ShowDeleteGameStatsMessage(selectedGame) != MessageDialogResult.Affirmative)
{
return;
}
if (!overall)
{
if (_deck.DeckStats.Games.Contains(selectedGame))
{
selectedGame.DeleteGameFile();
_deck.DeckStats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game: " + selectedGame);
DeckStatsList.Save();
}
}
else
{
var deck = Helper.MainWindow.DeckList.DecksList.FirstOrDefault(d => d.DeckStats.Games.Contains(selectedGame));
if (deck != null)
{
if (deck.DeckStats.Games.Contains(selectedGame))
{
selectedGame.DeleteGameFile();
deck.DeckStats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game: " + selectedGame);
DefaultDeckStats.Save();
}
}
else
{
var deckstats = DefaultDeckStats.Instance.DeckStats.FirstOrDefault(ds => ds.Games.Contains(selectedGame));
if (deckstats != null)
{
selectedGame.DeleteGameFile();
deckstats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game: " + selectedGame);
DefaultDeckStats.Save();
}
}
}
Helper.MainWindow.DeckPickerList.Items.Refresh();
Refresh();
}
else if (count > 1)
{
if (await window.ShowDeleteMultipleGameStatsMessage(count) != MessageDialogResult.Affirmative)
{
return;
}
foreach (var selectedItem in dataGrid.SelectedItems)
{
var selectedGame = selectedItem as GameStats;
if (selectedGame == null)
{
continue;
}
if (!overall)
{
if (_deck.DeckStats.Games.Contains(selectedGame))
{
selectedGame.DeleteGameFile();
_deck.DeckStats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game: " + selectedGame);
}
}
else
{
var deck = Helper.MainWindow.DeckList.DecksList.FirstOrDefault(d => d.DeckStats.Games.Contains(selectedGame));
if (deck != null)
{
if (deck.DeckStats.Games.Contains(selectedGame))
{
selectedGame.DeleteGameFile();
deck.DeckStats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game: " + selectedGame);
}
}
else
{
var deckstats = DefaultDeckStats.Instance.DeckStats.FirstOrDefault(ds => ds.Games.Contains(selectedGame));
if (deckstats != null)
{
selectedGame.DeleteGameFile();
deckstats.Games.Remove(selectedGame);
Logger.WriteLine("Deleted game: " + selectedGame);
}
}
}
}
DeckStatsList.Save();
DefaultDeckStats.Save();
Logger.WriteLine("Deleted " + count + " games");
Helper.MainWindow.DeckPickerList.Items.Refresh();
Refresh();
}
}
private void MoveGameToOtherDeck(GameStats selectedGame)
{
if (selectedGame == null)
{
return;
}
var heroes = new Dictionary <string, int>();
foreach (var turn in selectedGame.TurnStats)
{
foreach (var play in turn.Plays)
{
if (!play.Type.ToString().Contains("Player"))
{
continue;
}
var hero = Game.GetCardFromId(play.CardId).PlayerClass;
if (hero == null)
{
continue;
}
if (!heroes.ContainsKey(hero))
{
heroes.Add(hero, 0);
}
heroes[hero]++;
}
}
var heroPlayed = heroes.Any() ? heroes.OrderByDescending(x => x.Value).First().Key : "Any";
var possibleTargets = Helper.MainWindow.DeckList.DecksList.Where(d => d.Class == heroPlayed || heroPlayed == "Any");
var dialog = new MoveGameDialog(possibleTargets);
if (Config.Instance.StatsInWindow)
{
dialog.Owner = Helper.MainWindow.StatsWindow;
}
else
{
dialog.Owner = Helper.MainWindow;
}
dialog.ShowDialog();
var selectedDeck = dialog.SelectedDeck;
if (selectedDeck == null)
{
return;
}
var defaultDeck = DefaultDeckStats.Instance.DeckStats.FirstOrDefault(ds => ds.Games.Contains(selectedGame));
if (defaultDeck != null)
{
defaultDeck.Games.Remove(selectedGame);
DefaultDeckStats.Save();
}
else
{
_deck.DeckStats.Games.Remove(selectedGame);
}
selectedGame.PlayerDeckVersion = selectedDeck.Version; //move to latest version
selectedDeck.DeckStats.Games.Add(selectedGame);
DeckStatsList.Save();
Helper.MainWindow.WriteDecks();
Refresh();
Helper.MainWindow.DeckPickerList.UpdateList();
}
public int AddGames(List <Game> games)
{
Common.Log.Debug($"Tracker: Adding {games.Count} games");
var count = 0;
var newGames = new List <Game>();
Common.Log.Debug("Tracker: Reloading deck stats");
Reload <DeckStatsList>();
Reload <DefaultDeckStats>();
var gameStats = new List <GameStats>(DeckStatsList.Instance.DeckStats.Values
.SelectMany(x => x.Games));
gameStats.AddRange(DefaultDeckStats.Instance.DeckStats
.SelectMany(x => x.Games));
// create index maps into the list on id and GameIndex
var indexById = gameStats.ToDictionary(x => x.GameId, x => gameStats.IndexOf(x));
// create a fuzzy index based on start time and opponent
var fuzzyIndex = gameStats.ToDictionary(x => new GameIndex(x), x => indexById[x.GameId]);
foreach (var game in games)
{
// set default indices
var index = -1;
var gameIndex = new GameIndex(game);
if (game.Id != null && indexById.ContainsKey(game.Id))
{
// look for id match first
index = indexById[game.Id];
Common.Log.Debug($"Tracker: Existing game found with id {game.Id}");
}
else if (fuzzyIndex.ContainsKey(gameIndex))
{
// try a fuzzy match
index = fuzzyIndex[gameIndex];
Common.Log.Debug($"Tracker: Game fuzzy matched ({gameIndex.StartTime})");
}
// if the game was matched then edit it, otherwise add new game
if (index >= 0 && index < gameStats.Count)
{
var stats = gameStats[index];
// set the deck first, so it isn't overwritten
game.Deck = new Deck()
{
Name = stats.DeckName,
Id = stats.DeckId
};
game.CopyTo(stats);
count++;
Common.Log.Debug($"Tracker: Game updated ({game.Id})");
}
else
{
newGames.Add(game);
}
}
DeckStatsList.Save();
DefaultDeckStats.Save();
var newGamesAdded = 0;
if (newGames.Count > 0)
{
newGamesAdded = AddNewGames(newGames);
}
return(count + newGamesAdded);
}
private int AddNewGames(List <Game> games)
{
Common.Log.Debug($"Tracker: Adding {games.Count} new games");
Common.Log.Debug("Tracker: Refreshing deck status");
Reload <DeckStatsList>();
Reload <DefaultDeckStats>();
Reload <DeckList>();
var count = 0;
foreach (var g in games)
{
var success = false;
var name = g.Deck.Name.ToLowerInvariant();
var klass = GetClass(g);
if (!string.IsNullOrWhiteSpace(name))
{
// find a deck by name
// add it if it exists (latest version)
// if not create empty deck, and add to that
var decks = DeckList.Instance.Decks;
var deckMatches = decks.Where(d =>
d.Name.ToLowerInvariant() == name &&
d.Class.ToLower() == klass &&
!d.Archived);
// if only a single match use that deck
if (deckMatches.Count() == 1)
{
var match = deckMatches.First();
Common.Log.Debug($"Tracker: Matching deck found '{match.Name}' {match.DeckId}");
var gameStats = new GameStats();
// copy the game info
g.CopyTo(gameStats);
// add the matched deck to GameStats object
gameStats.DeckId = match.DeckId;
gameStats.DeckName = match.Name;
// if no deck version matches use latest
if (gameStats.PlayerDeckVersion == null ||
!match.VersionsIncludingSelf.Contains(gameStats.PlayerDeckVersion))
{
gameStats.PlayerDeckVersion = match.GetMaxVerion();
}
// if game id is empty create new one
if (gameStats.GameId == Guid.Empty)
{
gameStats.GameId = Guid.NewGuid();
}
// add game to hdt stats
DeckStatsList.Instance.DeckStats[match.DeckId].AddGameResult(gameStats);
success = true;
Common.Log.Debug($"Tracker: Game added to {match.Name} stats");
}
else
{
Common.Log.Debug($"Single deck matching '{name}' not found, using default stats");
}
}
if (!success)
{
// add to default class deck stats
if (!string.IsNullOrEmpty(klass))
{
var stats = DefaultDeckStats.Instance.GetDeckStats(klass);
var gameStats = new GameStats();
g.CopyTo(gameStats);
// if game id is empty create new one
if (gameStats.GameId == Guid.Empty)
{
gameStats.GameId = Guid.NewGuid();
}
stats.AddGameResult(gameStats);
success = true;
Common.Log.Debug($"Tracker: Game added to default {klass} stats");
}
else
{
Common.Log.Debug($"Tracker: Failed to add game {g.Id}");
}
}
count += success ? 1 : 0;
}
Common.Log.Debug($"Tracker: Saving deck stats");
DeckList.Save();
DeckStatsList.Save();
DefaultDeckStats.Save();
return(count);
}
private async void DeleteDeck(Deck deck, bool saveAndUpdate = true)
{
if (deck == null)
{
return;
}
var deckStats = DeckStatsList.Instance.DeckStats.FirstOrDefault(ds => ds.BelongsToDeck(deck));
if (deckStats != null)
{
if (deckStats.Games.Any())
{
if (Config.Instance.KeepStatsWhenDeletingDeck)
{
var defaultDeck = DefaultDeckStats.Instance.GetDeckStats(deck.Class);
if (defaultDeck != null)
{
defaultDeck.Games.AddRange(deckStats.Games);
}
DefaultDeckStats.Save();
Logger.WriteLine(string.Format("Moved deckstats for deck {0} to default stats", deck.Name), "Edit");
}
else
{
try
{
foreach (var game in deckStats.Games)
{
game.DeleteGameFile();
}
Logger.WriteLine("Deleted games from deck: " + deck.Name, "Edit");
}
catch (Exception)
{
Logger.WriteLine("Error deleting games", "Edit");
}
}
}
DeckStatsList.Instance.DeckStats.Remove(deckStats);
if (saveAndUpdate)
{
DeckStatsList.Save();
}
Logger.WriteLine("Removed deckstats from deck: " + deck.Name, "Edit");
}
if (HearthStatsAPI.IsLoggedIn && deck.HasHearthStatsId && await CheckHearthStatsDeckDeletion())
{
HearthStatsManager.DeleteDeckAsync(deck, false, true);
}
DeckList.Instance.Decks.Remove(deck);
if (saveAndUpdate)
{
DeckList.Save();
DeckPickerList.UpdateDecks();
DeckPickerList.UpdateArchivedClassVisibility();
}
ListViewDeck.ItemsSource = null;
Logger.WriteLine("Deleted deck: " + deck.Name, "Edit");
}
