public void OnGameStart()
{
m_CurrentDeck = new PlayedDeck();
m_procentForm.Show();
m_NeedFilterByClass = true;
}
public void RedrawDeck()
{
if (m_ShowDeck != null)
{
System.Drawing.Graphics pGraphics = this.CreateGraphics();
m_ShowDeck.DrawToGraphics(pGraphics);
}
else if (m_DeckList != null)
{
System.Drawing.Graphics pGraphics = this.CreateGraphics();
pGraphics.Clear(Color.Honeydew);
int count = m_DeckList.Count;
int CurrentX = 0;
for (int i = 0; i < count; i++)
{
kernal.PlayedDeck deck = m_DeckList[i];
Size deckSize = deck.GetSize();
var saveState = pGraphics.Save();
pGraphics.TranslateTransform(CurrentX, 0);
deck.DrawToGraphics(pGraphics);
pGraphics.Restore(saveState);
CurrentX += deckSize.Width;
}
}
}
public void OnGameStart(/*HearthDb.Enums.CardClass CardClass*/)
{
if (m_List != null)
{
m_List.Show();
}
m_CurrentDeck = new PlayedDeck();
//m_GameDecks = m_GameDecks.FilterDeck(CardClass);
}
public void Copy(DecksCollection decks)
{
int count = decks.m_Decks.Count;
for (int i = 0; i < count; i++)
{
PlayedDeck deck = new PlayedDeck();
deck.Copy(decks.m_Decks[i]);
m_Decks.Add(deck);
}
}
public double Compare(PlayedDeck deck)
{
int SameCardCount = 0;
int AllCardCount = 0;
double procent = 0;
var pEnum = deck.m_Cards.GetEnumerator();
for (; pEnum.MoveNext();)
{
//если в сыгранно в этой партии колоде 2 одинаковые карты, а в эталонной одна, то исходная логика нарушается
int testDeckCard = pEnum.Current.Value;
int idealDeckCard = HaveCard(pEnum.Current.Key);
AllCardCount += testDeckCard;
SameCardCount += Math.Min(testDeckCard, idealDeckCard);
}
procent = (double)SameCardCount / (double)AllCardCount;
return(procent);
}
public void SetShowDeckList(List <kernal.PlayedDeck> listDeck)
{
m_DeckList = listDeck;
m_ShowDeck = null;
int count = m_DeckList.Count;
Size formSize = new Size(0, 0);
for (int i = 0; i < count; i++)
{
Size deckSize = m_DeckList[i].GetSize();
formSize.Width += deckSize.Width;
formSize.Height = Math.Max(formSize.Height, deckSize.Height);
}
formSize.Width += (7 * 2); //бордеры формочки
formSize.Height += (30 + 6);
this.Size = formSize;
RedrawDeck();
}
public void SetShowDeck(kernal.PlayedDeck deck)
{
m_ShowDeck = deck;
m_DeckList = null;
System.Drawing.Size size = m_ShowDeck.GetSize();
size.Width += (7 * 2); //бордеры формочки
size.Height += (30 + 6);
if (size.Width < 100)
{
size.Width = 100;
}
if (size.Width < 100)
{
size.Width = 100;
}
Size = size;
RedrawDeck();
}
public List <PlayedDeck> GetBestDeckList(PlayedDeck playedDeck)
{
List <PlayedDeck> deckList = new List <PlayedDeck>();
Dictionary <string, List <FindDeckInfo> > m_DeckNameMap = new Dictionary <string, List <FindDeckInfo> >();
int count = m_Decks.Count;
for (int i = 0; i < count; i++)
{
PlayedDeck deck = m_Decks[i];
List <FindDeckInfo> FindDeckList = null;
string deckName = deck.GetDeckName();
if (!m_DeckNameMap.ContainsKey(deckName))
{
m_DeckNameMap.Add(deckName, new List <FindDeckInfo>());
}
FindDeckList = m_DeckNameMap[deckName];
FindDeckInfo info = new FindDeckInfo();
info.DeckNumber = i;
info.Procent = deck.Compare(playedDeck);
FindDeckList.Add(info);
}
var pEnum = m_DeckNameMap.GetEnumerator();
for (; pEnum.MoveNext();)
{
List <FindDeckInfo> deckListSort = pEnum.Current.Value;
deckListSort.Sort
(
delegate(FindDeckInfo deck1, FindDeckInfo deck2)
{
return(deck2.Procent.CompareTo(deck1.Procent));
}
);
FindDeckInfo info = deckListSort[0];
PlayedDeck findDeck = new PlayedDeck(m_Decks[info.DeckNumber].GetSerialzeDeck());
findDeck.SetFoundPercent(info.Procent);
playedDeck.ClearDeck(findDeck);
deckList.Add(findDeck);
}
return(deckList);
}
public void OnOpponentPlayCard(Hearthstone_Deck_Tracker.Hearthstone.Card card)
{
if (m_NeedFilterByClass)
{
var game = Hearthstone_Deck_Tracker.API.Core.Game;
if (game != null) //для игры
{
m_GameDecks = m_GameDecks.FilterDeck(utils.KlassConverter(game.Opponent.Class));
m_NeedFilterByClass = false;
}
else if (card.IsClassCard)//для отладки тестов (игры то нет)
{
m_GameDecks = m_GameDecks.FilterDeck(utils.KlassConverter(card.PlayerClass));
m_NeedFilterByClass = false;
}
}
if (!card.Collectible)
{
return;
}
if (card.IsCreated)
{
return;
}
m_CurrentDeck.AddCard(card);
List <PlayedDeck> deckList = m_GameDecks.GetBestDeckList(m_CurrentDeck);
deckList.Sort(delegate(PlayedDeck d1, PlayedDeck d2) { return(d2.GetFoundPercent().CompareTo(d1.GetFoundPercent())); });
m_BestDeck = deckList[0];
if (m_procentForm != null)
{
if (deckList.Count <= 8) //иначе по ширине в экран не влезет
{
m_procentForm.SetShowDeckList(deckList);
}
else
{
m_procentForm.SetShowDeck(m_BestDeck);
}
}
}
public void ClearDeck(PlayedDeck pDeck)
{
var enum1 = m_Cards.GetEnumerator();
for (; enum1.MoveNext();)
{
var enum2 = pDeck.m_Cards.GetEnumerator();
for (; enum2.MoveNext();)
{
if (enum1.Current.Key.Equals(enum2.Current.Key))
{
pDeck.m_Cards[enum1.Current.Key] = Math.Max(0, enum2.Current.Value - enum1.Current.Value);
if (pDeck.m_Cards[enum1.Current.Key] == 0)
{
pDeck.m_Cards.Remove(enum1.Current.Key);
}
break;
}
}
}
}
public PlayedDeck GetBestCompareDeck(PlayedDeck playedDeck)
{
int count = m_Decks.Count;
int number = 0;
double maxValue = m_Decks[0].Compare(playedDeck);
for (int i = 1; i < count; i++)
{
double temp = m_Decks[i].Compare(playedDeck);
if (temp > maxValue)
{
number = i;
maxValue = temp;
}
}
playedDeck.SetFoundPercent(maxValue);
PlayedDeck findDeck = new PlayedDeck(m_Decks[number].GetSerialzeDeck());
findDeck.SetFoundPercent(maxValue);
playedDeck.ClearDeck(findDeck);
return(findDeck);
}
public Dictionary <Hearthstone_Deck_Tracker.Hearthstone.Card, int> GetBestCompareDeck(PlayedDeck playedDeck)
{
int count = m_Decks.Count;
int number = 0;
double maxValue = m_Decks[0].Compare(playedDeck);
for (int i = 1; i < count; i++)
{
double temp = m_Decks[i].Compare(playedDeck);
if (temp > maxValue)
{
number = i;
maxValue = temp;
}
}
string fileName = GetDeckFolder() + "\\procent.txt";
System.IO.StreamWriter wr = new System.IO.StreamWriter(fileName);
wr.WriteLine(maxValue.ToString());
wr.Dispose();
Dictionary <Hearthstone_Deck_Tracker.Hearthstone.Card, int> BestDeck = new Dictionary <Hearthstone_Deck_Tracker.Hearthstone.Card, int>();
if (maxValue >= 0.8)
{
m_Decks[number].CopyToDict(BestDeck);
playedDeck.ClearDeck(BestDeck);
}
return(BestDeck);
}
public void RemoveDeck(PlayedDeck deck)
{
}
public void AddDeck(PlayedDeck deck)
{
m_Decks.Add(deck);
}
public void Copy(PlayedDeck deck)
{
m_Cards = new Dictionary <Hearthstone_Deck_Tracker.Hearthstone.Card, int>(deck.m_Cards);
m_Class = deck.m_Class;
}
