public void ShowIncorrectDeckMessage()
{
var decks =
DeckList.DecksList.Where(
d => d.Class == Game.PlayingAs && Game.PlayerDrawn.All(c => d.Cards.Contains(c))
).ToList();
if (decks.Contains(DeckPickerList.SelectedDeck))
{
decks.Remove(DeckPickerList.SelectedDeck);
}
Logger.WriteLine(decks.Count + " possible decks found.", "IncorrectDeckMessage");
if (decks.Count == 1 && Config.Instance.AutoSelectDetectedDeck)
{
var deck = decks.First();
Logger.WriteLine("Automatically selected deck: " + deck.Name);
DeckPickerList.SelectDeck(deck);
UpdateDeckList(deck);
UseDeck(deck);
}
else if (decks.Count > 0)
{
decks.Add(new Deck("Use no deck", "", new List <Card>(), new List <string>(), "", "", DateTime.Now));
var dsDialog = new DeckSelectionDialog(decks);
//todo: System.Windows.Data Error: 2 : Cannot find governing FrameworkElement or FrameworkContentElement for target element. BindingExpression:Path=ClassColor; DataItem=null; target element is 'GradientStop' (HashCode=7260326); target property is 'Color' (type 'Color')
//when opened for seconds time. why?
dsDialog.ShowDialog();
var selectedDeck = dsDialog.SelectedDeck;
if (selectedDeck != null)
{
if (selectedDeck.Name == "Use no deck")
{
DeselectDeck();
}
else
{
Logger.WriteLine("Selected deck: " + selectedDeck.Name);
DeckPickerList.SelectDeck(selectedDeck);
UpdateDeckList(selectedDeck);
UseDeck(selectedDeck);
}
}
else
{
this.ShowMessage("Deck detection disabled.", "Can be re-enabled in \"DECKS\" menu.");
CheckboxDeckDetection.IsChecked = false;
Config.Save();
}
}
IsShowingIncorrectDeckMessage = false;
NeedToIncorrectDeckMessage = false;
}
public void LoadAndUpdateDecks()
{
UpdateDeckList(DeckList.Instance.ActiveDeck);
SelectDeck(DeckList.Instance.ActiveDeck, true);
Helper.SortCardCollection(ListViewDeck.Items, Config.Instance.CardSortingClassFirst);
DeckPickerList.PropertyChanged += DeckPickerList_PropertyChanged;
DeckPickerList.UpdateDecks();
DeckPickerList.UpdateArchivedClassVisibility();
DeckPickerList.SelectDeck(DeckList.Instance.ActiveDeck);
ManaCurveMyDecks.UpdateValues();
}
public void SelectLastUsedDeck()
{
var lastSelected = DeckList.Instance.LastDeckClass.LastOrDefault();
var deck = DeckList.Instance.Decks.FirstOrDefault(d => lastSelected == null || d.DeckId == lastSelected.Id);
if (deck == null)
{
return;
}
DeckPickerList.SelectDeck(deck);
SelectDeck(deck, true);
}
private async void BtnCancelEdit_Click(object sender, RoutedEventArgs e)
{
if (_newDeckUnsavedChanges)
{
var result =
await
this.ShowMessageAsync(EditingDeck? "Cancel editing" : "Cancel deck creation",
EditingDeck? "All changes made to the deck will be lost." : "The new deck will be lost.",
MessageDialogStyle.AffirmativeAndNegative);
if (result != MessageDialogResult.Affirmative)
{
return;
}
}
CloseNewDeck();
EditingDeck = false;
_editedDeckName = string.Empty;
var prev = DeckPickerList.SelectedDecks.FirstOrDefault();
SelectLastUsedDeck();
DeckPickerList.SelectDeck(prev);
}
private async void SaveDeck(bool overwrite)
{
var deckName = TextBoxDeckName.Text;
if (string.IsNullOrEmpty(deckName))
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Set", DefaultText = deckName
};
var name = await this.ShowInputAsync("No name set", "Please set a name for the deck", settings);
if (String.IsNullOrEmpty(name))
{
return;
}
deckName = name;
TextBoxDeckName.Text = name;
}
while (DeckList.DecksList.Any(d => d.Name == deckName) && (!EditingDeck || !overwrite))
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Set", DefaultText = deckName
};
var name =
await
this.ShowInputAsync("Name already exists", "You already have a deck with that name, please select a different one.", settings);
if (String.IsNullOrEmpty(name))
{
return;
}
deckName = name;
TextBoxDeckName.Text = name;
}
if (_newDeck.Cards.Sum(c => c.Count) != 30)
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Yes", NegativeButtonText = "No"
};
var result =
await
this.ShowMessageAsync("Not 30 cards",
string.Format("Deck contains {0} cards. Is this what you want to save anyway?",
_newDeck.Cards.Sum(c => c.Count)),
MessageDialogStyle.AffirmativeAndNegative, settings);
if (result != MessageDialogResult.Affirmative)
{
return;
}
}
if (EditingDeck && overwrite)
{
DeckList.DecksList.Remove(_newDeck);
DeckPickerList.RemoveDeck(_newDeck);
}
var oldDeckName = _newDeck.Name;
_newDeck.Name = deckName;
_newDeck.Tags = TagControlEdit.GetTags();
var newDeckClone = (Deck)_newDeck.Clone();
DeckList.DecksList.Add(newDeckClone);
newDeckClone.LastEdited = DateTime.Now;
WriteDecks();
Logger.WriteLine("Saved Decks");
if (EditingDeck)
{
TagControlEdit.SetSelectedTags(new List <string>());
if (deckName != oldDeckName)
{
var statsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(d => d.Name == oldDeckName);
if (statsEntry != null)
{
if (overwrite)
{
statsEntry.Name = deckName;
Logger.WriteLine("Deck has new name, updated deckstats");
}
else
{
var newStatsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(d => d.Name == deckName);
if (newStatsEntry == null)
{
newStatsEntry = new DeckStats(deckName);
DeckStatsList.Instance.DeckStats.Add(newStatsEntry);
}
foreach (var game in statsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Logger.WriteLine("cloned gamestats for \"Set as new\"");
}
DeckStatsList.Save();
}
}
}
//after cloning the stats, otherwise new stats will be generated
DeckPickerList.AddAndSelectDeck(newDeckClone);
EditingDeck = false;
foreach (var tag in _newDeck.Tags)
{
SortFilterDecksFlyout.AddSelectedTag(tag);
}
DeckPickerList.UpdateList();
DeckPickerList.SelectDeck(newDeckClone);
CloseNewDeck();
ClearNewDeckSection();
}
public void SelectDeck(Deck deck, bool setActive)
{
if (DeckList.Instance.ActiveDeck != null)
{
DeckPickerList.ClearFromCache(DeckList.Instance.ActiveDeck);
}
if (deck != null)
{
//set up notes
DeckNotesEditor.SetDeck(deck);
var flyoutHeader = deck.Name.Length >= 20 ? string.Join("", deck.Name.Take(17)) + "..." : deck.Name;
FlyoutNotes.Header = flyoutHeader;
//set up tags
TagControlEdit.SetSelectedTags(DeckPickerList.SelectedDecks);
MenuItemQuickSetTag.ItemsSource = TagControlEdit.Tags;
MenuItemQuickSetTag.Items.Refresh();
DeckPickerList.MenuItemQuickSetTag.ItemsSource = TagControlEdit.Tags;
DeckPickerList.MenuItemQuickSetTag.Items.Refresh();
//set and save last used deck for class
if (setActive)
{
while (DeckList.Instance.LastDeckClass.Any(ldc => ldc.Class == deck.Class))
{
var lastSelected = DeckList.Instance.LastDeckClass.FirstOrDefault(ldc => ldc.Class == deck.Class);
if (lastSelected != null)
{
DeckList.Instance.LastDeckClass.Remove(lastSelected);
}
else
{
break;
}
}
if (Core.Initialized)
{
DeckList.Instance.LastDeckClass.Add(new DeckInfo {
Class = deck.Class, Name = deck.Name, Id = deck.DeckId
});
DeckList.Save();
}
Log.Info("Switched to deck: " + deck.Name);
int useNoDeckMenuItem = Core.TrayIcon.NotifyIcon.ContextMenu.MenuItems.IndexOfKey(TrayIcon.UseNoDeckMenuItemName);
Core.TrayIcon.NotifyIcon.ContextMenu.MenuItems[useNoDeckMenuItem].Checked = false;
}
}
else
{
Core.Game.IsUsingPremade = false;
if (DeckList.Instance.ActiveDeck != null)
{
DeckList.Instance.ActiveDeck.IsSelectedInGui = false;
}
DeckList.Instance.ActiveDeck = null;
if (setActive)
{
DeckPickerList.DeselectDeck();
}
var useNoDeckMenuItem = Core.TrayIcon.NotifyIcon.ContextMenu.MenuItems.IndexOfKey(TrayIcon.UseNoDeckMenuItemName);
Core.TrayIcon.NotifyIcon.ContextMenu.MenuItems[useNoDeckMenuItem].Checked = true;
}
if (setActive)
{
UseDeck(deck);
}
DeckPickerList.SelectDeck(deck);
UpdateDeckList(deck);
EnableMenuItems(deck != null);
ManaCurveMyDecks.SetDeck(deck);
UpdatePanelVersionComboBox(deck);
if (setActive)
{
Core.Overlay.ListViewPlayer.Items.Refresh();
Core.Windows.PlayerWindow.ListViewPlayer.Items.Refresh();
}
DeckManagerEvents.OnDeckSelected.Execute(deck);
}
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;
}
}
}
public async void ShowIncorrectDeckMessage()
{
if (Core.Game.Player.DrawnCards.Count == 0)
{
IsShowingIncorrectDeckMessage = false;
return;
}
//wait for player hero to be detected and at least 3 cards to be drawn
for (var i = 0; i < 50; i++)
{
if (Core.Game.Player.Class != null && Core.Game.Player.DrawnCards.Count >= 3)
{
break;
}
await Task.Delay(100);
}
if (string.IsNullOrEmpty(Core.Game.Player.Class) || Core.Game.Player.DrawnCards.Count < 3)
{
IsShowingIncorrectDeckMessage = false;
Log.Info("No player hero detected or less then 3 cards drawn. Not showing dialog.");
return;
}
await Task.Delay(1000);
if (!NeedToIncorrectDeckMessage)
{
IsShowingIncorrectDeckMessage = false;
return;
}
var decks =
DeckList.Instance.Decks.Where(
d =>
d.Class == Core.Game.Player.Class && !d.Archived && d.IsArenaRunCompleted != true &&
Core.Game.Player.DrawnCardIdsTotal.Distinct()
.All(id => d.GetSelectedDeckVersion().Cards.Any(c => id == c.Id)) &&
Core.Game.Player.DrawnCards.All(
c =>
d.GetSelectedDeckVersion()
.Cards.Any(c2 => c2.Id == c.Id && c2.Count >= c.Count))).ToList();
Log.Info(decks.Count + " possible decks found.");
Core.Game.NoMatchingDeck = decks.Count == 0;
if (decks.Any(x => x == DeckList.Instance.ActiveDeck))
{
Log.Info("Correct deck already selected.");
IsShowingIncorrectDeckMessage = false;
NeedToIncorrectDeckMessage = false;
return;
}
if (decks.Count == 1 && Config.Instance.AutoSelectDetectedDeck)
{
var deck = decks.First();
Log.Info("Automatically selected deck: " + deck.Name);
DeckPickerList.SelectDeck(deck);
UpdateDeckList(deck);
UseDeck(deck);
}
else
{
decks.Add(new Deck("Use no deck", "", new List <Card>(), new List <string>(), "", "", DateTime.Now, false, new List <Card>(),
SerializableVersion.Default, new List <Deck>(), false, "", Guid.Empty, ""));
if (decks.Count == 1 && DeckList.Instance.ActiveDeckVersion != null)
{
decks.Add(new Deck("No match - Keep using active deck", "", new List <Card>(), new List <string>(), "", "", DateTime.Now, false,
new List <Card>(), SerializableVersion.Default, new List <Deck>(), false, "", Guid.Empty, ""));
}
var dsDialog = new DeckSelectionDialog(decks);
dsDialog.ShowDialog();
var selectedDeck = dsDialog.SelectedDeck;
if (selectedDeck != null)
{
if (selectedDeck.Name == "Use no deck")
{
SelectDeck(null, true);
}
else if (selectedDeck.Name == "No match - Keep using active deck")
{
Core.Game.IgnoreIncorrectDeck = DeckList.Instance.ActiveDeck;
Log.Info($"Now ignoring {DeckList.Instance.ActiveDeck.Name} as an incorrect deck");
}
else
{
Log.Info("Selected deck: " + selectedDeck.Name);
DeckPickerList.SelectDeck(selectedDeck);
UpdateDeckList(selectedDeck);
UseDeck(selectedDeck);
}
}
else
{
this.ShowMessage("Auto deck selection disabled.", "This can be re-enabled by selecting \"AUTO\" in the bottom right of the deck picker.").Forget();
DeckPickerList.UpdateAutoSelectToggleButton();
Config.Save();
}
}
IsShowingIncorrectDeckMessage = false;
NeedToIncorrectDeckMessage = false;
}
public void SelectDeck(Deck deck, bool setActive)
{
if (DeckList.Instance.ActiveDeck != null)
{
DeckPickerList.ClearFromCache(DeckList.Instance.ActiveDeck);
}
if (deck != null)
{
//set up tags
TagControlEdit.SetSelectedTags(DeckPickerList.SelectedDecks);
DeckPickerList.MenuItemQuickSetTag.ItemsSource = TagControlEdit.Tags;
DeckPickerList.MenuItemQuickSetTag.Items.Refresh();
OnPropertyChanged(nameof(HsReplayButtonVisibility));
//set and save last used deck for class
if (setActive)
{
while (DeckList.Instance.LastDeckClass.Any(ldc => ldc.Class == deck.Class))
{
var lastSelected = DeckList.Instance.LastDeckClass.FirstOrDefault(ldc => ldc.Class == deck.Class);
if (lastSelected != null)
{
DeckList.Instance.LastDeckClass.Remove(lastSelected);
}
else
{
break;
}
}
if (Core.Initialized)
{
DeckList.Instance.LastDeckClass.Add(new DeckInfo {
Class = deck.Class, Name = deck.Name, Id = deck.DeckId
});
DeckList.Save();
}
Log.Info($"Switched to deck: {deck.Name} ({deck.SelectedVersion.ShortVersionString})");
Core.TrayIcon.MenuItemUseNoDeck.Checked = false;
}
if (FlyoutDeckScreenshot.IsOpen)
{
DeckScreenshotFlyout.Deck = deck.GetSelectedDeckVersion();
}
if (FlyoutDeckExport.IsOpen)
{
DeckExportFlyout.Deck = deck.GetSelectedDeckVersion();
}
if (FlyoutDeckHistory.IsOpen)
{
if (deck.HasVersions)
{
DeckHistoryFlyout.Deck = deck;
}
else
{
FlyoutDeckHistory.IsOpen = false;
}
}
}
else
{
Core.Game.IsUsingPremade = false;
if (DeckList.Instance.ActiveDeck != null)
{
DeckList.Instance.ActiveDeck.IsSelectedInGui = false;
}
DeckList.Instance.ActiveDeck = null;
if (setActive)
{
DeckPickerList.DeselectDeck();
}
Core.TrayIcon.MenuItemUseNoDeck.Checked = true;
}
if (setActive)
{
UseDeck(deck);
}
DeckPickerList.SelectDeck(deck);
UpdateDeckList(deck);
ManaCurveMyDecks.SetDeck(deck);
UpdatePanelVersionComboBox(deck);
GroupBoxHsReplayDeckInfo.Visibility = deck?.IsArenaDeck == true ? Collapsed : Visible;
if (setActive)
{
Core.Overlay.ListViewPlayer.Items.Refresh();
Core.Windows.PlayerWindow.ListViewPlayer.Items.Refresh();
}
DeckManagerEvents.OnDeckSelected.Execute(deck);
}
private async void SaveDeck(bool overwrite, SerializableVersion newVersion)
{
var deckName = TextBoxDeckName.Text;
if (string.IsNullOrEmpty(deckName))
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Set", DefaultText = deckName
};
var name = await this.ShowInputAsync("No name set", "Please set a name for the deck", settings);
if (String.IsNullOrEmpty(name))
{
return;
}
deckName = name;
TextBoxDeckName.Text = name;
}
/*while(DeckList.DecksList.Any(d => d.Name == deckName) && (!EditingDeck || !overwrite))
* {
* var settings = new MetroDialogSettings {AffirmativeButtonText = "Set", DefaultText = deckName};
* var name =
* await
* this.ShowInputAsync("Name already exists", "You already have a deck with that name, please select a different one.", settings);
*
* if(String.IsNullOrEmpty(name))
* return;
*
* deckName = name;
* TextBoxDeckName.Text = name;
* }*/
if (_newDeck.Cards.Sum(c => c.Count) != 30)
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Yes", NegativeButtonText = "No"
};
var result =
await
this.ShowMessageAsync("Not 30 cards",
string.Format("Deck contains {0} cards. Is this what you want to save anyway?",
_newDeck.Cards.Sum(c => c.Count)), MessageDialogStyle.AffirmativeAndNegative, settings);
if (result != MessageDialogResult.Affirmative)
{
return;
}
}
var previousVersion = _newDeck.Version;
if (overwrite && (_newDeck.Version != newVersion))
{
AddDeckHistory();
_newDeck.Version = newVersion;
_newDeck.SelectedVersion = newVersion;
_newDeck.HearthStatsDeckVersionId = "";
//UpdateDeckHistoryPanel(_newDeck, false);
}
if (EditingDeck && overwrite)
{
DeckList.Instance.Decks.Remove(_newDeck);
//DeckPickerList.RemoveDeck(_newDeck);
}
var oldDeckName = _newDeck.Name;
_newDeck.Name = deckName;
var newDeckClone = (Deck)_newDeck.Clone();
DeckList.Instance.Decks.Add(newDeckClone);
newDeckClone.LastEdited = DateTime.Now;
DeckList.Save();
Logger.WriteLine("Saved Decks", "SaveDeck");
if (EditingDeck)
{
TagControlEdit.SetSelectedTags(new List <string>());
if (deckName != oldDeckName)
{
var statsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(ds => ds.BelongsToDeck(_newDeck));
if (statsEntry != null)
{
if (overwrite)
{
statsEntry.Name = deckName;
Logger.WriteLine("Deck has new name, updated deckstats", "SaveDeck");
}
else
{
var newStatsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(ds => ds.BelongsToDeck(_newDeck));
if (newStatsEntry == null)
{
newStatsEntry = new DeckStats(_newDeck);
DeckStatsList.Instance.DeckStats.Add(newStatsEntry);
}
foreach (var game in statsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Logger.WriteLine("cloned gamestats for \"Set as new\"", "SaveDeck");
}
DeckStatsList.Save();
}
}
}
if (Config.Instance.HearthStatsAutoUploadNewDecks)
{
Logger.WriteLine("auto uploading new/edited deck", "SaveDeck");
if (EditingDeck)
{
if (previousVersion != newVersion)
{
HearthStatsManager.UploadVersionAsync(newDeckClone, _originalDeck.HearthStatsIdForUploading, background: true);
}
else
{
HearthStatsManager.UpdateDeckAsync(newDeckClone, background: true);
}
}
else
{
HearthStatsManager.UploadDeckAsync(newDeckClone, background: true);
}
}
//after cloning the stats, otherwise new stats will be generated
//DeckPickerList.AddAndSelectDeck(newDeckClone);
EditingDeck = false;
foreach (var tag in _newDeck.Tags)
{
SortFilterDecksFlyout.AddSelectedTag(tag);
}
if (Config.Instance.SelectedDeckType != DeckType.All)
{
if (newDeckClone.IsArenaDeck && Config.Instance.SelectedDeckType != DeckType.Arena)
{
DeckPickerList.SelectDeckType(DeckType.Arena);
}
else if (!newDeckClone.IsArenaDeck && Config.Instance.SelectedDeckType != DeckType.Constructed)
{
DeckPickerList.SelectDeckType(DeckType.Constructed);
}
}
if (!DeckPickerList.SelectedClasses.Contains(HeroClassAll.All))
{
HeroClassAll deckClass;
if (Enum.TryParse(newDeckClone.Class, out deckClass))
{
if (!DeckPickerList.SelectedClasses.Contains(deckClass))
{
DeckPickerList.SelectClasses(new List <HeroClassAll> {
deckClass
});
}
}
}
DeckPickerList.UpdateDecks();
DeckPickerList.SelectDeck(newDeckClone);
CloseNewDeck();
ClearNewDeckSection();
}