public async Task <string> EncodeDeckAsync(DecodedDeck deck)
{
if (deck == null)
{
return(null);
}
return(await DeckEncoder.EncodeAsync(deck));
}
/// <summary>
/// Encodes a decoded deck into a string for sharing
/// </summary>
/// <param name="deck">The decoded deck with hero id's and turns/counts</param>
/// <returns></returns>
public string EncodeDeck(DecodedDeck deck)
{
if (deck == null)
{
return(null);
}
return(DeckEncoder.Encode(deck));
}
public void EncodeDeck()
{
ArtifactClient client = new ArtifactClient();
string startDeckCode = "ADCJWkTZX05uwGDCRV4XQGy3QGLmqUBg4GQJgGLGgO7AaABR3JlZW4vQmxhY2sgRXhhbXBsZQ__";
DecodedDeck deck = client.DecodeDeck(startDeckCode);
string encodedDeckCode = client.EncodeDeck(deck);
Assert.AreEqual(startDeckCode, encodedDeckCode);
}
public void DecodeDeck()
{
ArtifactClient client = new ArtifactClient();
DecodedDeck deck = client.DecodeDeck("ADCJQUQI30zuwEYg2ABeF1Bu94BmWIBTEkLtAKlAZakAYmHh0JsdWUvUmVkIEV4YW1wbGU_");
Assert.IsNotNull(deck);
Assert.IsNotNull(deck.Heroes);
Assert.IsNotNull(deck.Cards);
Assert.IsFalse(string.IsNullOrEmpty(deck.Name));
}
/// <summary>
/// Decodes a base 64 string and returns the deck decoded
/// </summary>
/// <param name="deckCode">The base64 encoded string</param>
/// <returns>A decoded deck containing deck name, card id's and positions</returns>
public static DecodedDeck Decode(string deckCode)
{
byte[] deckBytes = DeckDecodeString(deckCode);
if (deckBytes == null)
{
return(null);
}
DecodedDeck deck = ParseDeck(deckCode, deckBytes);
return(deck);
}
public static async Task <DecodedDeck> DecodeAsync(string deckCode)
{
byte[] deckBytes = await Task.Run(() => DeckDecodeString(deckCode));
if (deckBytes == null)
{
return(null);
}
DecodedDeck deck = await Task.Run(() => ParseDeck(deckCode, deckBytes));
return(deck);
}
/// <summary>
/// Encodes a deck into a UTF-8 64bit encoded string
/// </summary>
/// <param name="deck"></param>
/// <returns></returns>
public static async Task <string> EncodeAsync(DecodedDeck deck)
{
if (deck == null)
{
return(null);
}
byte[] bytes = await Task.Run(() => EncodeToBytes(deck));
if (bytes == null)
{
return(null);
}
string deckCode = await Task.Run(() => EncodeBytesToString(bytes));
return(deckCode);
}
/// <summary>
/// Updated the whole UI using a deck code
/// </summary>
/// <param name="deckCode"></param>
/// <returns></returns>
private async Task Update(string deckCode)
{
//Decode the string into a deck. See if it's valid
DecodedDeck decodedDeck = await m_client.DecodeDeckAsync(deckCode);
if (decodedDeck == null)
{
Console.WriteLine("Unable to get deck. DeckCode is invald");
return;
}
g_Loading.Visibility = Visibility.Visible;
/*Reset all UI holder*/
if (img_HeroOne.Source != null)
{
img_HeroOne.Source = null;
}
if (img_HeroTwo.Source != null)
{
img_HeroTwo.Source = null;
}
if (img_HeroThree.Source != null)
{
img_HeroThree.Source = null;
}
if (img_HeroFour.Source != null)
{
img_HeroFour.Source = null;
}
if (img_HeroFive.Source != null)
{
img_HeroFive.Source = null;
}
await SetFocusedCard(-1, ArtType.Ingame, Enums.Language.English);
t_totalCards.Text = null;
t_totalItems.Text = null;
t_TCSpell.Text = null;
t_TCCreep.Text = null;
t_TCImprovement.Text = null;
t_TIarmor.Text = null;
t_TIweapon.Text = null;
t_TIhealth.Text = null;
t_TIconsumable.Text = null;
/*End of resetting UI holders*/
//Set the deck name title
tb_DeckName.Text = decodedDeck.Name;
//Decode the deck to the complete deck
Deck deck = await m_client.GetCardsFromDecodedDeckAsync(decodedDeck);
//Populate the hero UI
List <System.Windows.Controls.Image> heroImageHolders = new List <System.Windows.Controls.Image>()
{
img_HeroOne, img_HeroTwo, img_HeroThree, img_HeroFour, img_HeroFive
};
for (int i = 0; i < deck.Heroes.Count; i++)
{
int additional = 0;
int turn = deck.Heroes[i].Turn;
if (turn > 1)
{
turn += 2; //Add 2 because of heroImageHolders elements 0-2
}
//If the hero turn is 1, but already added a hero, then increase additional counter
while (heroImageHolders[turn - 1 + additional].Source != null)
{
additional++;
}
System.Windows.Controls.Image img = heroImageHolders[turn - 1 + additional];
img.Source = GetImageFromUrl(deck.Heroes[i].IngameImage.Default);
img.DataContext = deck.Heroes[i]; //Set context for click event finding card art
}
//Sort cards by mana cost & set UI
List <GenericCard> sortedList = deck.Cards.OrderBy(x => x.ManaCost).ToList();
ic_genericCardsList.ItemsSource = sortedList;
//Total cards excludes items, hence the separate total items UI
int totalGeneric = deck.Cards.Sum(x => x is GenericCard && x.Type == CardType.Item ? ((GenericCard)x).Count : 0);
t_totalCards.Text = $"{totalGeneric} CARDS";
t_totalItems.Text = $"{deck.Cards.Sum(x => x.Type == CardType.Item ? x.Count : 0)} ITEMS";
//Find out both colors of deck and get stats for each color
CardColor colorOne = GetOtherColor(deck.Cards, CardColor.None);
CardColor colorTwo = GetOtherColor(deck.Cards, colorOne | CardColor.None);
ManaDeckInfoDto deckManaInfo = new ManaDeckInfoDto()
{
OneManaCards = GetManaAmount(deck.Cards, 1),
TwoManaCards = GetManaAmount(deck.Cards, 2),
ThreeManaCards = GetManaAmount(deck.Cards, 3),
FourManaCards = GetManaAmount(deck.Cards, 4),
FiveManaCards = GetManaAmount(deck.Cards, 5),
SixManaCards = GetManaAmount(deck.Cards, 6),
SevenManaCards = GetManaAmount(deck.Cards, 7),
EightPlusManaCards = deck.Cards.Sum(x => x.ManaCost >= 8 ? x.Count : 0),
ColorOneBrush = FactionColorToBrush(colorOne),
ColorTwoBrush = FactionColorToBrush(colorTwo),
ColorOneTotalCardCount = deck.Cards.Sum(x => x.FactionColor == colorOne ? x.Count : 0),
ColorTwoTotalCardCount = deck.Cards.Sum(x => x.FactionColor == colorTwo ? x.Count : 0),
};
deckManaInfo.MaxManaCardCount = GetMaxMana(deckManaInfo.OneManaCards,
deckManaInfo.TwoManaCards,
deckManaInfo.ThreeManaCards,
deckManaInfo.FourManaCards,
deckManaInfo.FiveManaCards,
deckManaInfo.SixManaCards,
deckManaInfo.SevenManaCards,
deckManaInfo.EightPlusManaCards);
ic_deckStats.ItemsSource = new List <ManaDeckInfoDto>()
{
deckManaInfo
};
//Set relevant stat information for deck
t_TCSpell.Text = deck.Cards.Sum(x => x.Type == CardType.Spell ? x.Count : 0).ToString();
t_TCCreep.Text = deck.Cards.Sum(x => x.Type == CardType.Creep ? x.Count : 0).ToString();
t_TCImprovement.Text = deck.Cards.Sum(x => (x.Type == CardType.Improvement) ? x.Count : 0).ToString();
t_TIarmor.Text = deck.Cards.Sum(x => x.Type == CardType.Item && x.SubType == CardType.Armor ? x.Count : 0).ToString();
t_TIweapon.Text = deck.Cards.Sum(x => x.Type == CardType.Item && x.SubType == CardType.Weapon ? x.Count : 0).ToString();
t_TIhealth.Text = deck.Cards.Sum(x => x.Type == CardType.Item && x.SubType == CardType.Accessory ? x.Count : 0).ToString();
t_TIconsumable.Text = deck.Cards.Sum(x => x.Type == CardType.Item && x.SubType == CardType.Consumable ? x.Count : 0).ToString();
g_Loading.Visibility = Visibility.Collapsed;
}
private static byte[] EncodeToBytes(DecodedDeck deck)
{
if (deck == null || deck.Heroes == null || deck.Cards == null)
{
return(null);
}
//Combine hero and normal cards and sort by id
List <CardId> heroesSorted = deck.Heroes.Select(x => (CardId)x).OrderBy(x => x, new SortByComparer()).ToList();
List <CardId> cardsSorted = deck.Cards.Select(x => (CardId)x).OrderBy(x => x, new SortByComparer()).ToList();
int countHeroes = deck.Heroes.Count;
List <CardId> allCards = heroesSorted.Concat(cardsSorted).ToList();
byte[] bytes = new byte[0];
//our version and hero count
int intVersion = CurrentVersion << 4 | ExtractNBitsWithCarry(countHeroes, 3);
byte version = (byte)intVersion;
if (!AddByte(ref bytes, version))
{
return(null);
}
//the checksum which will be updated at the end
byte nDummyChecksum = 0;
int nChecksumByte = bytes.Length;
bool addByteResult = AddByte(ref bytes, nDummyChecksum);
if (!addByteResult)
{
return(null);
}
// write the name size
int nameLen = 0;
string name = "";
if (!string.IsNullOrEmpty(deck.Name))
{
// replace strip_tags() with your own HTML santizer or escaper.
name = Helper.StripTags(deck.Name);
int trimLen = name.Length;
while (trimLen > 63)
{
int amountToTrim = (int)Math.Floor((trimLen - 63.0) / 4.0);
amountToTrim = (amountToTrim > 1) ? amountToTrim : 1;
name = name.Substring(0, name.Length - amountToTrim);
trimLen = name.Length;
}
nameLen = name.Length;
}
addByteResult = AddByte(ref bytes, (byte)nameLen);
if (!addByteResult)
{
return(null);
}
int keepCount = countHeroes;
bool bufferResult = AddRemainingNumberToBuffer(ref countHeroes, 3, ref bytes);
if (!bufferResult)
{
return(null);
}
int unChecksum = 0;
int prevCardId = 0;
for (int unCurrHero = 0; unCurrHero < keepCount; unCurrHero++)
{
CardId card = allCards[unCurrHero];
DecodedHero casted = null;
if (card is DecodedHero)
{
casted = (DecodedHero)card;
}
else
{
continue;
}
if (casted.Turn == 0)
{
continue;
}
bufferResult = AddCardToBuffer(casted.Turn, card.Id - prevCardId, ref bytes, unChecksum);
if (!bufferResult)
{
continue;
}
prevCardId = casted.Id;
}
//reset our card offset
prevCardId = 0;
//now all of the cards
for (int nCurrCard = countHeroes; nCurrCard < allCards.Count; nCurrCard++)
{
//see how many cards we can group together
CardId card = allCards[nCurrCard];
if (card.Id <= 0)
{
continue;
}
DecodedCard castedCard = null;
if (card is DecodedCard)
{
castedCard = (DecodedCard)card;
}
else
{
continue;
}
if (castedCard.Count == 0)
{
continue;
}
//record this set of cards, and advance
bufferResult = AddCardToBuffer(castedCard.Count, castedCard.Id - prevCardId, ref bytes, unChecksum);
if (!bufferResult)
{
continue;
}
prevCardId = castedCard.Id;
}
// save off the pre string bytes for the checksum
int preStringByteCount = bytes.Length;
//write the string
if (!string.IsNullOrEmpty(name))
{
byte[] nameBytes = System.Text.Encoding.UTF8.GetBytes(name);
foreach (byte nameByte in nameBytes)
{
addByteResult = AddByte(ref bytes, nameByte);
if (!addByteResult)
{
return(null);
}
}
}
int unFullChecksum = ComputeChecksum(ref bytes, preStringByteCount - HeaderSize);
int unSmallChecksum = (unFullChecksum & 0x0FF);
bytes[nChecksumByte] = (byte)unSmallChecksum;
return(bytes);
}
/// <summary>
/// Encodes a deck into a UTF-8 64bit encoded string
/// </summary>
/// <param name="deck">The </param>
/// <returns></returns>
public static string Encode(DecodedDeck deck)
{
return(Task.Run(() => EncodeAsync(deck)).Result);
}
/// <summary>
/// Converts a DecodedDeck to return a complete deck with all stats
/// </summary>
/// <param name="decodedDeck">A DecodedDeck</param>
/// <returns>A complete deck with cards and their info</returns>
public async Task <Deck> GetCardsFromDecodedDeckAsync(DecodedDeck decodedDeck)
{
if (decodedDeck == null)
{
return(null);
}
List <HeroCard> heroCards = new List <HeroCard>();
List <GenericCard> genericCards = new List <GenericCard>();
foreach (DecodedHero dHero in decodedDeck.Heroes)
{
Card card = await GetCardAsync(dHero.Id);
if (card == null || !(card is HeroCard))
{
continue;
}
HeroCard heroCard = (HeroCard)card;
heroCard.Turn = dHero.Turn;
if (heroCard.References != null)
{
foreach (Reference referenceCard in heroCard.References)
{
Card refCard = await GetCardAsync(referenceCard.Id);
if (refCard is SignatureCard)
{
genericCards.Add((SignatureCard)refCard);
}
}
}
heroCards.Add(heroCard);
}
foreach (DecodedCard dCard in decodedDeck.Cards)
{
Card card = await GetCardAsync(dCard.Id);
if (card == null || !(card is GenericCard))
{
continue;
}
GenericCard genericCard = card as GenericCard;
genericCard.Count = dCard.Count;
genericCards.Add(genericCard);
}
Deck d = new Deck()
{
Name = decodedDeck.Name,
Heroes = heroCards,
Cards = genericCards,
};
return(d);
}
/// <summary>
/// Converts a DecodedDeck to return a complete deck with all stats
/// </summary>
/// <param name="decodedDeck">A DecodedDeck</param>
/// <returns>A complete deck with cards and their info</returns>
public Deck GetCardsFromDecodedDeck(DecodedDeck decodedDeck)
{
return(Task.Run(() => GetCardsFromDecodedDeckAsync(decodedDeck)).Result);
}