public void Transform(Deck deck)
{
var cardIds = new HashSet <string>();
cardIds.UnionWith(deck.MainDeck.Order);
cardIds.UnionWith(deck.Sideboard.Order);
var releaseDate = cardIds.Max(
cardId => _repo.CardsById[cardId].Printings.Min(
setcode => _repo.SetsByCode[setcode].ReleaseDate));
var replacements = new Dictionary <string, string>();
foreach (string cardId in cardIds)
{
var card = _repo.CardsById[cardId];
var candidates = card.Printings
.Select(setcode => _repo.SetsByCode[setcode])
.Where(set => Str.Compare(set.ReleaseDate, releaseDate) <= 0)
.AtMax(set => set.ReleaseDate)
.Find()
.CardsByName[card.NameNormalized];
var replacement =
candidates.FirstOrDefault(_ => _.ImageName == card.ImageName) ??
candidates.First();
replacements.Add(cardId, replacement.Id);
}
deck.Replace(replacements);
}
//[TestCase("pMEI")]
public void MapCards(string minSetCode)
{
var tcgParser = new TcgParser();
var tcgSetsBySet = tcgParser.GetTcgSetBySet();
var tcgCardsByTcgSet = tcgParser.GetTcgCardsByTcgSet();
var orderByCard = tcgParser.GetOrderByCard();
var preProcessedTcgNameByCode = new Dictionary <TcgCard, string>();
foreach (var cardsByCode in tcgCardsByTcgSet.Values)
{
foreach (var tcgCard in cardsByCode.Values)
{
preProcessedTcgNameByCode.Add(tcgCard, preProcessTcgName(tcgCard));
}
}
foreach (var set in Repo.SetsByCode.Values.OrderBy(_ => _.ReleaseDate))
{
if (minSetCode != null && Str.Compare(set.Code, minSetCode) < 0)
{
continue;
}
if (!tcgSetsBySet.TryGetValue(set.Code, out string tcgSet))
{
continue;
}
var tcgCards = tcgCardsByTcgSet[tcgSet];
foreach (var pair in set.CardsByName.OrderBy(_ => _.Key))
{
var cards = pair.Value
.OrderBy(_ => _.Number)
.ThenBy(card => card.ImageName)
.ToList();
string name = preProcessMtgjsonName(cards[0]);
var matchingTcgCards = tcgCards
.Where(_ => preProcessedTcgNameByCode[_.Value].Equals(name, Str.Comparison))
.OrderBy(_ => orderByCard.TryGet(tcgSet)?.TryGet(_.Key))
.ThenBy(_ => _.Value.Number)
.ThenBy(_ => _.Value.Name)
.ToList();
removeFoilDuplicates(matchingTcgCards);
if (matchingTcgCards.Count != 1 || cards.Count != 1)
{
var message = new StringBuilder();
message.Append(set.Code);
message.Append(" -> ");
message.AppendLine(tcgSet);
for (int i = 0; i < cards.Count || i < matchingTcgCards.Count; i++)
{
message.Append("\t");
if (i < cards.Count)
{
message.Append(cards[i].ImageName);
message.Append(" [");
message.Append(cards[i].Artist);
message.Append(']');
}
else
{
message.Append("?");
}
message.Append(" -> ");
if (i < matchingTcgCards.Count)
{
message.Append($"{matchingTcgCards[i].Key} #{matchingTcgCards[i].Value.Number} {matchingTcgCards[i].Value.Name}");
}
else
{
message.Append("?");
}
message.AppendLine();
}
Log.Info(message.ToString());
}
}
}
}
private void refilter(Action onFinished)
{
var touchedCard = _deckEditor.TouchedCard;
bool showDuplicates = _buttonShowDuplicates.Checked;
var filterManagerStates = FilterManager.States;
_breakRefreshing = true;
lock (_searchResultCards)
{
_breakRefreshing = false;
var searchResultCards = new List <Card>();
var filteredCards = new List <Card>();
var allCards = _sort.SortedCards;
if (showDuplicates)
{
for (int i = 0; i < allCards.Count; i++)
{
if (_breakRefreshing)
{
return;
}
var card = allCards[i];
bool isFiltered = fit(card, filterManagerStates);
if (isFiltered || card == touchedCard)
{
searchResultCards.Add(card);
}
if (isFiltered)
{
filteredCards.Add(card);
}
}
}
else
{
var cardsByName = new Dictionary <string, Card>();
for (int i = 0; i < allCards.Count; i++)
{
if (_breakRefreshing)
{
return;
}
var card = allCards[i];
if (fit(card, filterManagerStates))
{
bool isCurrentCardMoreRecent;
if (!cardsByName.TryGetValue(card.NameNormalized, out var otherCard))
{
isCurrentCardMoreRecent = true;
}
else
{
var dateCompare = Str.Compare(card.ReleaseDate, otherCard.ReleaseDate);
if (dateCompare > 0)
{
isCurrentCardMoreRecent = true;
}
else if (dateCompare == 0)
{
isCurrentCardMoreRecent = card.IndexInFile < otherCard.IndexInFile;
}
else
{
isCurrentCardMoreRecent = false;
}
}
if (isCurrentCardMoreRecent)
{
cardsByName[card.NameNormalized] = card;
}
}
}
for (int i = 0; i < allCards.Count; i++)
{
if (_breakRefreshing)
{
return;
}
var card = allCards[i];
bool isFiltered = cardsByName.TryGet(card.NameNormalized) == card;
if (isFiltered || card == touchedCard)
{
searchResultCards.Add(card);
}
if (isFiltered)
{
filteredCards.Add(card);
}
}
}
// implicit connection: data_source_sync
lock (_searchResultCards)
{
_searchResultCards.Clear();
_searchResultCards.AddRange(searchResultCards);
}
_filteredCards.Clear();
_filteredCards.UnionWith(filteredCards);
updateIsSearchResult();
}
this.Invoke(delegate
{
_imagePreloading.Reset();
refreshData();
onFinished?.Invoke();
});
}
