internal async void BtnCloneSelectedVersion_Click(object sender, RoutedEventArgs e)
{
var deck = DeckPickerList.SelectedDecks.FirstOrDefault();
if (deck == null)
{
return;
}
deck = deck.GetSelectedDeckVersion();
var cloneStats =
(await
this.ShowMessageAsync("Clone game history?", "(Cloned games do not count towards class or overall stats.)",
MessageDialogStyle.AffirmativeAndNegative,
new MessageDialogs.Settings
{
AffirmativeButtonText = "clone history",
NegativeButtonText = "do not clone history"
})) == MessageDialogResult.Affirmative;
var clone = (Deck)deck.CloneWithNewId(false);
clone.ResetVersions();
clone.ResetHearthstatsIds();
clone.Archived = false;
var originalStatsEntry = clone.DeckStats;
DeckList.Instance.Decks.Add(clone);
DeckPickerList.UpdateDecks();
DeckList.Save();
var newStatsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(ds => ds.BelongsToDeck(clone));
if (newStatsEntry == null)
{
newStatsEntry = new DeckStats(clone);
DeckStatsList.Instance.DeckStats.Add(newStatsEntry);
}
//clone game stats
if (cloneStats)
{
foreach (var game in originalStatsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Logger.WriteLine("cloned gamestats (version)", "Edit");
}
DeckStatsList.Save();
//DeckPickerList.UpdateList();
DeckPickerList.SelectDeckAndAppropriateView(clone);
if (Config.Instance.HearthStatsAutoUploadNewDecks && HearthStatsAPI.IsLoggedIn)
{
HearthStatsManager.UploadDeckAsync(clone).Forget();
}
}
public async Task UpdateStats(DeckStats stats, Deck deck)
{
var context = _context;
if (stats.Decks_ID == deck.ID)
{
var oldStats = await context.StatsTable
.FirstOrDefaultAsync(x => x.Decks_ID == deck.ID);
var newCorrect = stats.Correct;
var newInCorrect = stats.InCorrect;
var newTotalPct = stats.TotalPct;
if (oldStats != null)
{
oldStats.Correct = newCorrect;
oldStats.InCorrect = newInCorrect;
oldStats.TotalPct = newTotalPct;
}
}
else
{
stats.Decks_ID = context.DecksTable
.Where(x => x.User_ID == UserId && x.Name == deck.Name)
.Select(x => x.ID).FirstOrDefault();
await context.AddAsync(stats);
}
await context.SaveChangesAsync();
}
public async Task DeleteStats(DeckStats stats)
{
var context = _context;
context.Attach(stats);
context.Remove(stats);
await context.SaveChangesAsync();
}
private async void BtnCloneDeck_Click(object sender, RoutedEventArgs e)
{
var cloneStats =
(await
this.ShowMessageAsync("Clone game history?", "(Cloned games do not count towards class or overall stats.)",
MessageDialogStyle.AffirmativeAndNegative,
new MetroDialogSettings
{
AffirmativeButtonText = "clone history",
NegativeButtonText = "do not clone history"
})) == MessageDialogResult.Affirmative;
var clone = (Deck)DeckPickerList.SelectedDeck.Clone();
var originalStatsEntry = clone.DeckStats;
while (DeckList.DecksList.Any(d => d.Name == clone.Name))
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Set", DefaultText = clone.Name
};
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;
}
clone.Name = name;
}
DeckList.DecksList.Add(clone);
DeckPickerList.AddAndSelectDeck(clone);
WriteDecks();
var newStatsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(d => d.Name == clone.Name);
if (newStatsEntry == null)
{
newStatsEntry = new DeckStats(clone.Name);
DeckStatsList.Instance.DeckStats.Add(newStatsEntry);
}
//clone game stats
if (cloneStats)
{
foreach (var game in originalStatsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Logger.WriteLine("cloned gamestats");
}
DeckStatsList.Save();
DeckPickerList.UpdateList();
}
public void Reset()
{
TurnNumber = 0;
ActivePlayer = null;
foreach (var p in Player.All)
{
foreach (var g in p.Groups)
{
g.Reset();
}
foreach (var c in p.Counters)
{
c.Reset();
}
foreach (var g in Definition.Player.GlobalVariables)
{
p.GlobalVariables[g.Key] = g.Value.Value;
}
}
foreach (var p in AllPhases)
{
p.Hold = false;
}
CurrentPhase = null;
Table.Reset();
Card.Reset();
CardIdentity.Reset();
Selection.Clear();
if (Definition.GameBoards.ContainsKey(""))
{
GameBoard = Definition.GameBoards[""];
BoardImage = GameBoard.Source;
}
else
{
GameBoard = null;
BoardImage = null;
}
foreach (var g in Definition.GlobalVariables)
{
GlobalVariables[g.Key] = g.Value.Value;
}
DeckStats.Reset();
//fix MAINWINDOW bug
PlayWindow mainWin = WindowManager.PlayWindow;
mainWin.RaiseEvent(new CardEventArgs(CardControl.CardHoveredEvent, mainWin));
EventProxy.OnGameStart_3_1_0_0();
EventProxy.OnGameStart_3_1_0_1();
EventProxy.OnGameStarted_3_1_0_2();
}
internal async void BtnCloneDeck_Click(object sender, RoutedEventArgs e)
{
var deck = DeckPickerList.SelectedDecks.FirstOrDefault();
if (deck == null)
{
return;
}
var cloneStats =
(await
this.ShowMessageAsync("Clone game history?", "(Cloned games do not count towards class or overall stats.)",
MessageDialogStyle.AffirmativeAndNegative,
new MessageDialogs.Settings
{
AffirmativeButtonText = "clone history",
NegativeButtonText = "do not clone history"
})) == MessageDialogResult.Affirmative;
var clone = (Deck)deck.CloneWithNewId(false);
clone.ResetHearthstatsIds();
clone.Versions.ForEach(v => v.ResetHearthstatsIds());
clone.Archived = false;
var originalStats = deck.DeckStats;
DeckList.Instance.Decks.Add(clone);
DeckList.Save();
DeckStats newStatsEntry;
if (!DeckStatsList.Instance.DeckStats.TryGetValue(clone.DeckId, out newStatsEntry))
{
newStatsEntry = new DeckStats(clone);
DeckStatsList.Instance.DeckStats.TryAdd(clone.DeckId, newStatsEntry);
}
if (cloneStats)
{
foreach (var game in originalStats.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Log.Info("cloned gamestats");
}
DeckStatsList.Save();
DeckPickerList.SelectDeckAndAppropriateView(clone);
if (Config.Instance.HearthStatsAutoUploadNewDecks && HearthStatsAPI.IsLoggedIn)
{
HearthStatsManager.UploadDeckAsync(clone).Forget();
}
}
internal async void BtnCloneSelectedVersion_Click(object sender, RoutedEventArgs e)
{
var deck = DeckPickerList.SelectedDecks.FirstOrDefault();
if (deck == null)
{
return;
}
deck = deck.GetSelectedDeckVersion();
var cloneStats =
(await
this.ShowMessageAsync("Clone game history?", "(Cloned games do not count towards class or overall stats.)",
MessageDialogStyle.AffirmativeAndNegative,
new MessageDialogs.Settings
{
AffirmativeButtonText = "clone history",
NegativeButtonText = "do not clone history"
})) == MessageDialogResult.Affirmative;
var clone = (Deck)deck.CloneWithNewId(false);
clone.ResetVersions();
clone.Archived = false;
var originalStatsEntry = clone.DeckStats;
DeckList.Instance.Decks.Add(clone);
DeckPickerList.UpdateDecks();
DeckList.Save();
DeckStats newStatsEntry;
if (!DeckStatsList.Instance.DeckStats.TryGetValue(clone.DeckId, out newStatsEntry))
{
newStatsEntry = new DeckStats(clone);
DeckStatsList.Instance.DeckStats.TryAdd(clone.DeckId, newStatsEntry);
}
//clone game stats
if (cloneStats)
{
foreach (var game in originalStatsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Log.Info("cloned gamestats (version)");
}
DeckStatsList.Save();
//DeckPickerList.UpdateList();
DeckPickerList.SelectDeckAndAppropriateView(clone);
}
protected Task UpdateState()
{
UserDecks = DeckState.UserDecks;
SelectedDeck = DeckState.SelectedDeck;
if (SelectedDeck != null)
{
DeckStats = DeckState.DeckStats;
DeckCards = SelectedDeck?.Cards ?? DeckState.Cards;
}
StateHasChanged();
return(Task.CompletedTask);
}
public async Task ResetDeckStats(Deck deck)
{
DeckStats = new DeckStats
{
Deck = deck,
Correct = 0,
InCorrect = 0,
TotalPct = 0
};
await Database.UpdateStats(DeckStats, SelectedDeck);
await NotifyStateChanged();
}
private async void BtnCloneDeck_Click(object sender, RoutedEventArgs e)
{
var clone = (Deck)Helper.MainWindow.DeckPickerList.SelectedDeck.Clone();
var originalStatsEntry = clone.DeckStats;
while (Helper.MainWindow.DeckList.DecksList.Any(d => d.Name == clone.Name))
{
var settings = new MetroDialogSettings();
settings.AffirmativeButtonText = "Set";
settings.DefaultText = clone.Name;
var name =
await
Helper.MainWindow.ShowInputAsync("Name already exists",
"You already have a deck with that name, please select a different one.", settings);
if (String.IsNullOrEmpty(name))
{
return;
}
clone.Name = name;
}
Helper.MainWindow.DeckList.DecksList.Add(clone);
Helper.MainWindow.DeckPickerList.AddAndSelectDeck(clone);
Helper.MainWindow.WriteDecks();
//clone game stats
var newStatsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(d => d.Name == clone.Name);
if (newStatsEntry == null)
{
newStatsEntry = new DeckStats(clone.Name);
DeckStatsList.Instance.DeckStats.Add(newStatsEntry);
}
foreach (var game in originalStatsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Logger.WriteLine("cloned gamestats");
DeckStatsList.Save();
Helper.MainWindow.DeckPickerList.UpdateList();
After_Click();
}
public async Task AddStats(DeckStats stats, Deck deck)
{
if (stats.ID > 0)
{
return;
}
var context = _context;
// Match name and user_id to find stored DecksTable primary key
stats.Decks_ID = context.DecksTable
.Where(x => x.User_ID == UserId && x.Name == deck.Name)
.Select(x => x.ID).FirstOrDefault();
await context.AddAsync(stats);
await context.SaveChangesAsync();
}
internal async void ShowCloneDeckDialog(Deck deck)
{
if (deck == null)
{
return;
}
var cloneStats =
(await
this.ShowMessageAsync("Clone game history?", "(Cloned games do not count towards class or overall stats.)",
MessageDialogStyle.AffirmativeAndNegative,
new MessageDialogs.Settings
{
AffirmativeButtonText = "clone history",
NegativeButtonText = "do not clone history"
})) == MessageDialogResult.Affirmative;
var clone = (Deck)deck.CloneWithNewId(false);
clone.Archived = false;
var originalStats = deck.DeckStats;
DeckList.Instance.Decks.Add(clone);
DeckList.Save();
DeckStats newStatsEntry;
if (!DeckStatsList.Instance.DeckStats.TryGetValue(clone.DeckId, out newStatsEntry))
{
newStatsEntry = new DeckStats(clone);
DeckStatsList.Instance.DeckStats.TryAdd(clone.DeckId, newStatsEntry);
}
if (cloneStats)
{
foreach (var game in originalStats.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Log.Info("cloned gamestats");
}
DeckStatsList.Save();
DeckPickerList.SelectDeckAndAppropriateView(clone);
}
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();
}
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();
newDeckClone.Archived = false;
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 && HearthStatsAPI.IsLoggedIn)
{
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);
}
DeckPickerList.SelectDeckAndAppropriateView(newDeckClone);
CloseNewDeck();
ClearNewDeckSection();
}
internal async void BtnCloneSelectedVersion_Click(object sender, RoutedEventArgs e)
{
var deck = DeckPickerList.SelectedDecks.FirstOrDefault();
if (deck == null)
{
return;
}
var cloneStats =
(await
this.ShowMessageAsync("Clone game history?", "(Cloned games do not count towards class or overall stats.)",
MessageDialogStyle.AffirmativeAndNegative,
new MetroDialogSettings
{
AffirmativeButtonText = "clone history",
NegativeButtonText = "do not clone history"
})) == MessageDialogResult.Affirmative;
var clone = (Deck)deck.CloneWithNewId(false);
// bug #1316 - ResetVersions needs the current version as an argument
clone.ResetVersions();
clone.ResetHearthstatsIds();
clone.Archived = false;
var originalStatsEntry = clone.DeckStats;
/*while(DeckList.DecksList.Any(d => d.Name == clone.Name))
* {
* var settings = new MetroDialogSettings {AffirmativeButtonText = "Set", DefaultText = clone.Name};
* 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;
*
* clone.Name = name;
* }*/
DeckList.Instance.Decks.Add(clone);
DeckPickerList.UpdateDecks();
DeckList.Save();
var newStatsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(ds => ds.BelongsToDeck(clone));
if (newStatsEntry == null)
{
newStatsEntry = new DeckStats(clone);
DeckStatsList.Instance.DeckStats.Add(newStatsEntry);
}
//clone game stats
if (cloneStats)
{
foreach (var game in originalStatsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Logger.WriteLine("cloned gamestats (version)", "Edit");
}
DeckStatsList.Save();
//DeckPickerList.UpdateList();
DeckPickerList.SelectDeckAndAppropriateView(clone);
if (Config.Instance.HearthStatsAutoUploadNewDecks && HearthStatsAPI.IsLoggedIn)
{
HearthStatsManager.UploadDeckAsync(clone);
}
}
//Temporarily store group visibility information for LoadDeck. //bug (google) #20
public void LoadDeck(IDeck deck, bool limited)
{
var def = Program.GameEngine.Definition;
int nCards = deck.CardCount();
var ids = new int[nCards];
var keys = new Guid[nCards];
var cards = new Card[nCards];
var groups = new Play.Group[nCards];
var sizes = new string[nCards];
var gtmps = new List <GrpTmp>(); //for temp groups visibility
int j = 0;
foreach (var section in deck.Sections)
{
{ // Add cards to LoadedCards deck
if (!LoadedCards.Sections.Any(x => x.Name == section.Name))
{
// Add section
((ObservableCollection <ObservableSection>)LoadedCards.Sections).Add(new ObservableSection()
{
Name = section.Name,
Shared = section.Shared,
Cards = new ObservableCollection <ObservableMultiCard>()
});
}
var loadedCardsSection = LoadedCards.Sections.Single(x => x.Name == section.Name);
foreach (var card in section.Cards)
{
var existingCard = loadedCardsSection.Cards.FirstOrDefault(x => x.Id == card.Id);
if (existingCard != null)
{
existingCard.Quantity += card.Quantity;
}
else
{
var newCard = new ObservableMultiCard(card);
loadedCardsSection.Cards.AddCard(newCard);
}
}
}
DeckSection sectionDef = null;
sectionDef = section.Shared ? def.SharedDeckSections[section.Name] : def.DeckSections[section.Name];
if (sectionDef == null)
{
throw new InvalidFileFormatException("Invalid section '" + section.Name + "' in deck file.");
}
var player = section.Shared ? Player.GlobalPlayer : Player.LocalPlayer;
Play.Group group = player.Groups.First(x => x.Name == sectionDef.Group.Name); //TODO: match directly to SectionDef Group instead of name matching
//In order to make the clients know what the card is (if visibility is set so that they can see it),
//we have to set the visibility to Nobody, and then after the cards are sent, set the visibility back
//to what it was. //bug (google) #20
var gt = new GrpTmp(group, group.Visibility, group.Viewers.ToList());
if (!gtmps.Contains(gt))
{
gtmps.Add(gt);
group.SetVisibility(false, false);
}
foreach (IMultiCard element in section.Cards)
{
//DataNew.Entities.Card mod = Definition.GetCardById(element.Id);
for (int i = 0; i < element.Quantity; i++)
{
//for every card in the deck, generate a unique key for it, ID for it
var id = element.GenerateCardId();
var card = new Card(player, id, new DataNew.Entities.Card(element), true, element.Size.Name);
// var card = element.ToPlayCard(player);
ids[j] = card.Id;
keys[j] = card.Type.Model.Id;
//keys[j] = card.GetEncryptedKey();
groups[j] = group;
sizes[j] = card.Size.Name;
cards[j++] = card;
group.AddAt(card, group.Count);
DeckStats.AddCard(card);
}
// Load images in the background
string pictureUri = element.GetPicture();
Dispatcher.CurrentDispatcher.BeginInvoke(
new Func <string, BitmapImage>(ImageUtils.CreateFrozenBitmap),
DispatcherPriority.Background, pictureUri);
}
}
string sleeveString = null;
if (deck.Sleeve != null)
{
try {
var loadSleeve = true;
if (!IsLocal)
{
var isSubscriber = SubscriptionModule.Get().IsSubscribed;
if (isSubscriber == null)
{
loadSleeve = false;
Log.Warn("Can't set deck sleeve, unable to determin if user is a subscriber.");
Program.GameMess.Warning($"Deck sleeve can not be loaded, subscriber status is unknown.");
}
else if (isSubscriber == false)
{
loadSleeve = false;
Log.Warn("Not authorized to use deck sleeve.");
Program.GameMess.Warning($"Deck sleeve can not be used, you're not a subscriber.");
}
}
if (loadSleeve)
{
Player.LocalPlayer.SetSleeve(deck.Sleeve);
sleeveString = Sleeve.ToString(deck.Sleeve);
}
else
{
Log.Info("Sleeve will not be loaded.");
}
} catch (Exception ex) {
Log.Warn(ex.Message, ex);
Program.GameMess.Warning($"There was an error loading the decks sleeve.");
}
}
Program.Client.Rpc.LoadDeck(ids, keys, groups, sizes, sleeveString ?? string.Empty, limited);
//reset the visibility to what it was before pushing the deck to everybody. //bug (google) #20
foreach (GrpTmp g in gtmps)
{
switch (g.Visibility)
{
case GroupVisibility.Everybody:
g.Group.SetVisibility(true, false);
break;
case GroupVisibility.Nobody:
g.Group.SetVisibility(false, false);
break;
default:
foreach (Player p in g.Viewers)
{
g.Group.AddViewer(p, false);
}
break;
}
}
gtmps.Clear();
gtmps.TrimExcess();
}
public void Reset(bool isSoft)
{
TurnNumber = 0;
ActivePlayer = null;
foreach (var p in Player.All)
{
foreach (var g in p.Groups)
{
g.Reset();
}
foreach (var c in p.Counters)
{
c.Reset();
}
foreach (var g in Definition.Player.GlobalVariables)
{
p.GlobalVariables[g.Key] = g.Value.Value;
}
}
foreach (var p in AllPhases)
{
p.Hold = false;
}
CurrentPhase = null;
Table.Reset();
Card.Reset();
CardIdentity.Reset();
Selection.Clear();
ResetTableView();
foreach (var g in Definition.GlobalVariables)
{
GlobalVariables[g.Key] = g.Value.Value;
}
DeckStats.Reset();
//fix MAINWINDOW bug
PlayWindow mainWin = WindowManager.PlayWindow;
mainWin.RaiseEvent(new CardEventArgs(CardControl.CardHoveredEvent, mainWin));
EventProxy.OnGameStart_3_1_0_0();
EventProxy.OnGameStart_3_1_0_1();
EventProxy.OnGameStarted_3_1_0_2();
if (isSoft)
{
var currentDeck = new Deck()
{
GameId = LoadedCards.GameId,
IsShared = LoadedCards.IsShared,
Notes = LoadedCards.Notes,
Sections = LoadedCards.Sections.ToList(),
Sleeve = LoadedCards.Sleeve
};
LoadedCards.Sections = new ObservableCollection <ObservableSection>();
LoadDeck(currentDeck, false);
}
else
{
LoadedCards.Sections = new ObservableCollection <ObservableSection>();
}
}
public async void SaveDeck(bool overwrite, SerializableVersion newVersion, bool workInProgressDeck = false)
{
var deckName = TextBoxDeckName.Text;
if (string.IsNullOrEmpty(deckName))
{
var settings = new MessageDialogs.Settings {
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;
}
if (_newDeck.Cards.Sum(c => c.Count) != 30 && workInProgressDeck == false)
{
var settings = new MessageDialogs.Settings {
AffirmativeButtonText = "Yes", NegativeButtonText = "No"
};
var result =
await
this.ShowMessageAsync("Not 30 cards",
$"Deck contains {_newDeck.Cards.Sum(c => c.Count)} cards. Is this what you want to save anyway?", 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 = "";
}
if (EditingDeck && overwrite)
{
DeckList.Instance.Decks.Remove(_newDeck);
}
var oldDeckName = _newDeck.Name;
_newDeck.Name = deckName;
var newDeckClone = (Deck)_newDeck.Clone();
newDeckClone.Archived = false;
DeckList.Instance.Decks.Add(newDeckClone);
newDeckClone.LastEdited = DateTime.Now;
DeckList.Save();
Log.Info("Saved Decks");
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;
Log.Info("Deck has new name, updated deckstats");
foreach (var game in statsEntry.Games)
{
game.DeckName = deckName;
}
}
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());
}
Log.Info("cloned gamestats for \"Set as new\"");
}
DeckStatsList.Save();
}
}
}
if (Config.Instance.HearthStatsAutoUploadNewDecks && HearthStatsAPI.IsLoggedIn)
{
Log.Info("auto uploading new/edited deck");
if (EditingDeck)
{
if (previousVersion != newVersion)
{
HearthStatsManager.UploadVersionAsync(newDeckClone, _originalDeck.HearthStatsIdForUploading, background: true).Forget();
}
else
{
HearthStatsManager.UpdateDeckAsync(newDeckClone, background: true).Forget();
}
}
else
{
HearthStatsManager.UploadDeckAsync(newDeckClone, background: true).Forget();
}
}
if (EditingDeck)
{
DeckManagerEvents.OnDeckUpdated.Execute(newDeckClone);
}
else
{
DeckManagerEvents.OnDeckCreated.Execute(newDeckClone);
}
EditingDeck = false;
foreach (var tag in _newDeck.Tags)
{
SortFilterDecksFlyout.AddSelectedTag(tag);
}
DeckPickerList.SelectDeckAndAppropriateView(newDeckClone);
DeckPickerList.UpdateDecks(forceUpdate: new[] { newDeckClone });
SelectDeck(newDeckClone, true);
CloseNewDeck();
ClearNewDeckSection();
}
public override void RefreshData()
{
if (refreshing)
{
return;
}
refreshing = true;
LoadData();
DeckStats.Clear();
var newstats = new BindableCollection <IDictionary <Deck, IList <StatModel> > >();
Task.Run(
() =>
{
using (Busy.GetTicket())
{
foreach (Deck deck in Decks)
{
if (!String.IsNullOrEmpty(GameMode))
{
var gameMode = (GameMode)Enum.Parse(typeof(GameMode), GameMode);
if (gameMode == Data.GameMode.Arena)
{
var emptystats = new Dictionary <Deck, IList <StatModel> >();
newstats.Add(emptystats);
var emptylst = new List <StatModel>();
emptystats.Add(deck, emptylst);
emptylst.AddRange(Heroes.Select(h => new StatModel()
{
Hero = h
}));
continue;
}
}
var r =
gameRepository.Query(
x =>
{
var q = x.Where(g => g.Deck.Id == deck.Id);
q = q.Where(GetFilterExpression());
var group = q
.Where(g => q.Any())
.GroupBy(g => g.OpponentHero.Key)
.Select(
g =>
new
{
HeroKey = g.Key,
GlobalTotal = q.Count(),
Total = g.Count(),
TotalCoin = g.Count(c => !c.GoFirst),
TotalNoCoin = g.Count(c => c.GoFirst),
Wins = g.Count(c => c.Victory),
Losses = g.Count(c => !c.Victory),
WinsCoin = g.Count(c => c.Victory && !c.GoFirst),
WinsNoCoin = g.Count(c => c.Victory && c.GoFirst),
LossesCoin = g.Count(c => !c.Victory && !c.GoFirst),
LossesNoCoin = g.Count(c => !c.Victory && c.GoFirst)
});
return(group.ToList());
});
if (r.Sum(x => x.GlobalTotal) == 0)
{
continue;
}
var stats = new Dictionary <Deck, IList <StatModel> >();
newstats.Add(stats);
var lst = new List <StatModel>();
stats.Add(deck, lst);
for (int i = 0; i < Heroes.Count; i++)
{
var oppHero = Heroes[i];
dynamic result = null;
if (oppHero.Key != null)
{
result = r.FirstOrDefault(x => x.HeroKey == oppHero.Key);
}
else
{
result = new
{
HeroKey = String.Empty,
GlobalTotal = r.Sum(x => x.Total),
Total = r.Sum(x => x.Total),
TotalCoin = r.Sum(x => x.TotalCoin),
TotalNoCoin = r.Sum(x => x.TotalNoCoin),
Wins = r.Sum(x => x.Wins),
Losses = r.Sum(x => x.Losses),
WinsCoin = r.Sum(x => x.WinsCoin),
WinsNoCoin = r.Sum(x => x.WinsNoCoin),
LossesCoin = r.Sum(x => x.LossesCoin),
LossesNoCoin = r.Sum(x => x.LossesNoCoin)
};
}
if (result == null)
{
lst.Add(new StatModel()
{
Hero = oppHero
});
}
else
{
lst.Add(
new StatModel()
{
Hero = oppHero,
TotalGames = result.Total,
GlobalTotal = result.GlobalTotal,
Wins = result.Wins,
Losses = result.Losses,
WinsCoin = result.WinsCoin,
WinsNoCoin = result.WinsNoCoin,
LossesCoin = result.LossesCoin,
LossesNoCoin = result.LossesNoCoin,
WinRate = result.Total > 0 ? Math.Round((decimal)result.Wins / result.Total * 100, 0) : 0,
LossRate = result.Total > 0 ? Math.Round((decimal)result.Losses / result.Total * 100, 0) : 0,
WinRateCoin =
result.TotalCoin > 0 ? Math.Round((decimal)result.WinsCoin / result.TotalCoin * 100, 0) : 0,
WinRateNoCoin =
result.TotalNoCoin > 0 ? Math.Round((decimal)result.WinsNoCoin / result.TotalNoCoin * 100, 0) : 0,
LossRateCoin =
result.TotalCoin > 0 ? Math.Round((decimal)result.LossesCoin / result.TotalCoin * 100, 0) : 0,
LossRateNoCoin =
result.TotalNoCoin > 0 ? Math.Round((decimal)result.LossesNoCoin / result.TotalNoCoin * 100, 0) : 0
});
}
}
}
refreshing = false;
}
}).ContinueWith(
t =>
{
using (Busy.GetTicket())
{
DeckStats.IsNotifying = false;
DeckStats.Clear();
DeckStats.AddRange(newstats);
DeckStats.IsNotifying = true;
DeckStats.Refresh();
}
});;
}
/// <summary>
/// Saves deck for a user
/// </summary>
public async Task SaveUserDeck(SaveDeckRequest request)
{
LambdaLogger.Log($"Entering: SaveUserDeck({ JsonConvert.SerializeObject(request) })");
try
{
DeckStats deckStats = new DeckStats
{
CommanderName = request.CommanderName,
DeckName = request.DeckName,
Name = MTGServiceConstants.DeckStatsCardName,
UserName = request.UserName,
DeckMetricsJson = JsonConvert.SerializeObject(request.DeckMetrics)
};
var existingDeckStats = SvcContext.Repository
.DeckStats
.FindFromUserAndDeckName(request.UserName, request.DeckName);
if (existingDeckStats != null)
{
LambdaLogger.Log($"About to delete old deck stats: { request.DeckName }");
await SvcContext.Repository
.DeckStats
.Delete(existingDeckStats);
}
var existingDeckCards = SvcContext.Repository
.DeckCards
.FindFromUserAndDeckName(request.UserName, request.DeckName);
if (existingDeckCards.Any())
{
LambdaLogger.Log($"About to delete old deck cards: { request.DeckName }");
await SvcContext.Repository
.DeckCards
.Delete(existingDeckCards);
}
LambdaLogger.Log($"About to save deck stats: { JsonConvert.SerializeObject(deckStats) }");
await SvcContext.Repository
.DeckStats
.SaveAsync(new List <DeckStats> {
deckStats
});
LambdaLogger.Log($"About to save deck cards for user: { request.UserName } & commander: { request.CommanderName }");
var config = new MapperConfiguration(x =>
{
x.CreateMap <Card, DeckCard>();
});
var mapper = config.CreateMapper();
var cards = SvcContext.Repository
.Cards
.FindFromNames(request.DeckCards.Select(x => x.Name).ToList())
.ToList();
var deckCards = new List <DeckCard>();
foreach (var card in cards)
{
if (card != null)
{
LambdaLogger.Log($"Found card for saved deck card: { JsonConvert.SerializeObject(card) }");
var newDeckCard = mapper.Map <Card, DeckCard>(card);
newDeckCard.DeckName = request.DeckName;
newDeckCard.UserName = request.UserName;
deckCards.Add(newDeckCard);
}
}
LambdaLogger.Log($"About to save cards: { JsonConvert.SerializeObject(deckCards) }");
await SvcContext.Repository
.DeckCards
.SaveAsync(deckCards);
}
catch (Exception exp)
{
LambdaLogger.Log($"Error: { exp }");
throw;
}
LambdaLogger.Log($"Leaving: SaveUserDeck({ JsonConvert.SerializeObject(request) })");
}
