public void DecksEdited_NewDeck()
{
List <Hearthstone.Deck> decks = null;
List <Hearthstone.Deck> added = null;
List <Hearthstone.Deck> removed = null;
List <Hearthstone.Deck> edited = null;
LoadDecks();
Assert.AreEqual(2, _collection.Decks.Count());
_collection.DecksChanged += args =>
{
decks = args.Items.ToList();
added = args.Added.ToList();
removed = args.Removed.ToList();
edited = args.Edited.ToList();
};
var deck = DeckSerializer.Deserialize("AAECAZ8FBvQF2a4CucECg8cCteYCt+cCDKcF9QXZB7EIu68C/68CuMcC2ccC48sC+NIC1uUCieYCAA==");
deck.DeckId = 3;
deck.Name = "new deck";
_collection.OnDeckEdited(new DeckEditedEventArgs(deck));
Assert.IsNotNull(decks);
Assert.AreEqual(3, decks.Count);
Assert.AreEqual(deck.Name, decks.Single(x => x.DeckId == 3).Name);
Assert.IsNotNull(added);
Assert.AreEqual(1, added.Count);
Assert.AreEqual(deck.Name, added.Single().Name);
Assert.IsNotNull(removed);
Assert.AreEqual(0, removed.Count);
Assert.IsNotNull(edited);
Assert.AreEqual(0, edited.Count);
}
public static void LoadPlayerCreatedDecksFromFile()
{
string path = Path.Combine(Config.SavedDataFolder(), Config.SavedDecksFile());
List <string> lines = File.ReadAllLines(path).ToList();
List <string> decksToLoad = new List <string>();
string input = "";
for (int i = 0; i < lines.Count; i++)
{
input = input + lines[i] + "\n";
if (lines.Count == i + 1)
{
decksToLoad.Add(input);
input = "";
}
else
{
if (lines[i + 1].StartsWith("###"))
{
decksToLoad.Add(input);
input = "";
}
}
}
decksToLoad.ForEach(x => CurrentDecks.Add(DeckSerializer.Deserialize(x)));
Log.Info("Successfully loaded player created decks from file.");
}
public void TestReserialize()
{
var deck = DeckSerializer.Deserialize(DeckString);
var reserialized = DeckSerializer.Serialize(deck, false);
Assert.AreEqual(DeckString, reserialized);
}
public void CardIdCollisionDeck_ValidShortId()
{
var hearthDbDeck = DeckSerializer.Deserialize("AAEBAf0EHnGeAcABwwG7Au4CqwSWBewF9w2JDroWwxbXtgLrugLYuwLZuwKHvQLBwQKP0wKi0wLu9gKnggP1iQP8owOSpAO+pAO/pAPdqQP0qwMAAA==");
var deck = HearthDbConverter.FromHearthDbDeck(hearthDbDeck);
var shortid = ShortIdHelper.GetShortId(deck);
Assert.AreEqual(shortid, "mA9O7wXvzxMsx1KO7EuFve");
}
public void HighlanderHunter_ValidShortId()
{
var hearthDbDeck = DeckSerializer.Deserialize("AAECAR8engGoArUDxwOHBMkErgbFCNsJ7Qn+DJjwAp7wAu/xAqCAA6eCA5uFA/WJA+aWA/mWA76YA7acA56dA/yjA+WkA5+lA6KlA6alA4SnA5+3AwAA");
var deck = HearthDbConverter.FromHearthDbDeck(hearthDbDeck);
var shortid = ShortIdHelper.GetShortId(deck);
Assert.AreEqual(shortid, "O2VpFDQokIrwww8iOmE3Lc");
}
public void ComboPriest_ValidShortId()
{
var hearthDbDeck = DeckSerializer.Deserialize("AAECAa0GBqUJ+wzl9wLQ/gKnhwOppQMM+ALlBPYH1QjRCtIK8gz3DK+lA9KlA/2nA4SoAwA=");
var deck = HearthDbConverter.FromHearthDbDeck(hearthDbDeck);
var shortid = ShortIdHelper.GetShortId(deck);
Assert.AreEqual(shortid, "0gsPp02q8ajKsGVstRwLpb");
}
public void BasicMageDeck_ValidShortId()
{
var hearthDbDeck = DeckSerializer.Deserialize("AAECAf0EAA9NWtgBtAK7AosDqwS0BOAE+wSWBYoH7AeeCZYNAA==");
var deck = HearthDbConverter.FromHearthDbDeck(hearthDbDeck);
var shortid = ShortIdHelper.GetShortId(deck);
Assert.AreEqual(shortid, "KtYDbAkM8IjSSyLMWQn5zb");
}
public void GetDeckstring()
{
const string deckstring = "AAEBAYDTAgSyAq8EkbwCnOICDbQB7QKoBdQF3QiStgKBwgLrwgKbywLKywKmzgL70wLb4wIA";
var hdbDeck = DeckSerializer.Deserialize(deckstring);
var deck = new Hearthstone.Deck(DeckType.Constructed, hdbDeck);
Assert.AreEqual(deckstring, deck.GetDeckstring());
}
public void Parse(Line line)
{
const string findingGameWithHero = "Finding Game With Hero: ";
if (line.Text == "Deck Contents Received:")
{
_state = State.ReceivingDecks;
InvokeFoundDecksAsync();
}
else if (line.Text == "Finished Editing Deck:")
{
UpdateState(State.FinishedEditingDeck);
}
else if (_findingGame.Contains(line.Text))
{
UpdateState(State.FindingGameWithDeck);
}
else if (line.Text.StartsWith(findingGameWithHero))
{
UpdateState(State.FindingGameWithHero);
if (int.TryParse(line.Text.Substring(findingGameWithHero.Length), out var dbfId))
{
FindingGame?.Invoke(new QueuedForGameEventArgs(dbfId));
}
}
else
{
if (_currentDeck.Count > 0 || line.Text.StartsWith("#"))
{
_currentDeck.Add(line.Text);
}
if (_currentDeck.Count == 3)
{
try
{
var deck = DeckSerializer.Deserialize(string.Join("\n", _currentDeck));
if (_state == State.FindingGameWithDeck)
{
FindingGame?.Invoke(new QueuedForGameEventArgs(deck));
}
else if (_state == State.FinishedEditingDeck)
{
EditedDeck?.Invoke(new DeckEditedEventArgs(deck));
}
else
{
_current.Add(deck);
}
}
catch (Exception e)
{
Log.Error(e);
}
_currentDeck.Clear();
}
}
}
public static void SavePlayerCreatedDecksToFile()
{
List <string> deckStrings = CurrentDecks.Select(x => DeckSerializer.Serialize(x, true)).ToList();
string path = Path.Combine(Config.SavedDataFolder(), Config.SavedDecksFile());
File.WriteAllLines(path, deckStrings);
Log.Info("Successfully saved player created decks to file.");
}
public static async Task <Deck> TryFindDeck(string url)
{
try
{
var doc = await ImportingHelper.GetHtmlDoc(url);
var deck = new Deck();
var metaNodes = doc.DocumentNode.SelectNodes("//meta");
if (!metaNodes.Any())
{
return(null);
}
deck.Name = GetMetaProperty(metaNodes, "x-hearthstone:deck");
deck.Url = GetMetaProperty(metaNodes, "x-hearthstone:deck:url") ?? url;
var deckString = GetMetaProperty(metaNodes, "x-hearthstone:deck:deckstring");
if (!string.IsNullOrEmpty(deckString))
{
try
{
var hearthDbDeck = DeckSerializer.Deserialize(deckString);
var fromDeckString = HearthDbConverter.FromHearthDbDeck(hearthDbDeck);
fromDeckString.Name = deck.Name;
fromDeckString.Url = deck.Url;
return(fromDeckString);
}
catch (Exception e)
{
Log.Error(e);
}
}
var heroId = GetMetaProperty(metaNodes, "x-hearthstone:deck:hero");
if (!string.IsNullOrEmpty(heroId))
{
deck.Class = Hearthstone.Database.GetCardFromId(heroId).PlayerClass;
}
var cardList = GetMetaProperty(metaNodes, "x-hearthstone:deck:cards").Split(',');
foreach (var idGroup in cardList.GroupBy(x => x))
{
var card = Hearthstone.Database.GetCardFromId(idGroup.Key);
card.Count = idGroup.Count();
deck.Cards.Add(card);
if (deck.Class == null && card.IsClassCard)
{
deck.Class = card.PlayerClass;
}
}
return(deck);
}
catch (Exception e)
{
Log.Error(e);
return(null);
}
}
public void DeserializeWithComments()
{
var deck = DeckSerializer.Deserialize(FullDeckString);
Assert.AreEqual("Warrior123", deck.Name);
Assert.AreEqual(30, deck.GetCards().Values.Sum());
var serialized = DeckSerializer.Serialize(deck, false);
Assert.AreEqual(DeckString, serialized);
}
public void TestSerializerCommentsDefaults()
{
var deck = DeckSerializer.Deserialize(DeckString);
var commented = DeckSerializer.Serialize(deck, true);
var lines = commented.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual("### Warrior Deck", lines[0]);
Assert.AreEqual("# Class: Warrior", lines[1]);
Assert.AreEqual("# Format: Standard", lines[2]);
}
public void TestDeckStrings()
{
var deck = DeckSerializer.Deserialize(DeckString);
Assert.AreEqual(CardIds.Collectible.Warrior.GarroshHellscreamHeroHeroSkins, deck.GetHero().Id);
var cards = deck.GetCards();
Assert.AreEqual(30, cards.Values.Sum());
var heroicStroke = cards.FirstOrDefault(c => c.Key.Id == CardIds.Collectible.Warrior.HeroicStrike);
Assert.IsNotNull(heroicStroke);
Assert.AreEqual(2, heroicStroke.Value);
}
private void LoadDecks()
{
var deck1 = DeckSerializer.Deserialize("AAECAZ8FBvQFucECg8cC1uUCteYCt+cCDKcF9QXZB7EI2a4Cu68C/68CuMcC2ccC48sC+NICieYCAA==");
deck1.DeckId = 1;
var deck2 = DeckSerializer.Deserialize("AAECAf0GBOCsApfTAp3iAtvpAg2KAZME9wS2B+EH3sQC58sC8tAC+NACiNICi+EC/OUC6OcCAA==");
deck2.DeckId = 2;
_collection.OnDecksLoaded(new ConstructedDeckFoundEventArgs(new List <Deck>
{
deck1,
deck2
}));
}
public void TestDeckStringsClassic()
{
var deck = DeckSerializer.Deserialize(ClassicDeckstring);
Assert.AreEqual(CardIds.Collectible.Druid.MalfurionStormrage_EliseStarseekerHeroHeroSkins, deck.GetHero().Id);
var cards = deck.GetCards();
Assert.AreEqual(30, cards.Values.Sum());
var claw = cards.FirstOrDefault(c => c.Key.Id == CardIds.Collectible.Druid.ClawVanilla);
Assert.IsNotNull(claw);
Assert.AreEqual(1, claw.Value);
Assert.AreEqual(FormatType.FT_CLASSIC, deck.Format);
}
public static async Task <Deck> Import(bool rethrow = false)
{
Exception error = null;
try
{
var clipboard = Clipboard.GetText();
var validUrl = Uri.TryCreate(clipboard, UriKind.Absolute, out Uri uriResult) &&
(uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
if (validUrl)
{
return(await DeckImporter.Import(clipboard));
}
try
{
var hearthDbDeck = DeckSerializer.Deserialize(clipboard);
var deck = HearthDbConverter.FromHearthDbDeck(hearthDbDeck);
if (deck != null)
{
return(deck);
}
}
catch (Exception e)
{
error = e;
Log.Error(e);
if (rethrow)
{
throw error;
}
}
if (StringImporter.IsValidImportString(clipboard))
{
return(StringImporter.Import(clipboard));
}
return(JsonDeckImporter.Import(clipboard));
}
catch (Exception ex)
{
Log.Error(ex);
if (rethrow)
{
throw error ?? ex;
}
return(null);
}
}
public void TestSerializerComments()
{
var deck = DeckSerializer.Deserialize(DeckString);
deck.Name = "Warrior123";
deck.ZodiacYear = ZodiacYear.MAMMOTH;
var commented = DeckSerializer.Serialize(deck, true);
var lines = commented.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual("### Warrior123", lines[0]);
Assert.AreEqual("# Class: Warrior", lines[1]);
Assert.AreEqual("# Format: Standard", lines[2]);
Assert.AreEqual("# Year of the Mammoth", lines[3]);
}
/// <summary>
/// Generates a deckcode for the deck that was last played during the game
/// </summary>
/// <returns></returns>
public string GenerateDeckCode()
{
// Extract deckcode
string deckcode;
try
{
deckcode = DeckSerializer.Serialize(this, false);
}
catch (Exception exc)
{
Log.Error(exc);
throw new Exception("Exception while serializing played deck");
}
// And return it
Hearthstone_Deck_Tracker.Utility.Logging.Log.Info(deckcode);
return(deckcode);
}
private void LoadDeckSerializer()
{
const int totalSteps = 4;
ResetProgressBar(totalSteps);
// Set messages
mLoadResults.Text = "Loading...";
mInfoGrid.Rows.Clear();
IncrementBar();
// Attempt to download sheet into our temp location
// If download fails, default to LKG
string fileToUse;
try
{
using (var client = new WebClient())
{
client.DownloadFile(kGoogleSheetSourceURL, kTempBookFileName);
}
fileToUse = kTempBookFileName;
}
catch (Exception)
{
fileToUse = kLKGBookFileName;
}
IncrementBar();
// We can't do anything if we both failed to download and had no available Last Known Good
if (!File.Exists(fileToUse))
{
mLoadResults.Text = "Failed download with no available LKG";
return;
}
// Load serializer, this will throw on fail
mDeckSerializer = new DeckSerializer(fileToUse, "みんなの日本語");
mDeckSerializer.LoadDecks();
IncrementBar();
// Report invalid decks
List <Deck> invalidDecks = mDeckSerializer.GetInvalidDecks();
bool hasErrors = false;
bool hasEmptyDecks = false;
if (invalidDecks.Count > 0)
{
foreach (Deck deck in invalidDecks)
{
List <string> errors = deck.GetErrors();
if (errors.Count > 0)
{
hasErrors = true;
foreach (string error in errors)
{
AddToInfoGrid(deck, error, true);
}
}
else if (deck.GetCardCount() == 0)
{
hasEmptyDecks = true;
AddToInfoGrid(deck, "Empty deck");
}
else
{
hasErrors = true;
AddToInfoGrid(deck, "Marked as invalid, but unable to identify why", true);
}
}
}
if (hasErrors)
{
mLoadResults.Text = "Errors present; fully valid decks still loaded.";
}
else
{
mLoadResults.Text = (hasEmptyDecks ? "Success, but with empty decks" : "Success!");
// Serializer loaded successfully (we didn't throw an exception during it)
// If we used a file other than LKG, swap
if (fileToUse != kLKGBookFileName)
{
if (File.Exists(kLKGBookFileName))
{
File.Delete(kLKGBookFileName);
}
File.Move(fileToUse, kLKGBookFileName);
}
}
IncrementBar();
// Update our interface with the new values
mBookAndChapterNumbers = mDeckSerializer.GetBookAndChapterNumbers();
mTrackBarMin.Maximum = mBookAndChapterNumbers.Count - 1;
mTrackBarMax.Maximum = mTrackBarMin.Maximum;
mTrackBarMax.Value = mTrackBarMin.Maximum;
UpdateAggregateDisplay();
}
