public static async Task ClearDeck(ExportingInfo info)
{
if (!Config.Instance.AutoClearDeck)
{
return;
}
var count = 0;
Logger.WriteLine("Clearing deck...", "DeckExporter");
while (!ExportingHelper.IsDeckEmpty(info.HsHandle, info.HsRect.Width, info.HsRect.Height, info.Ratio))
{
await
MouseActions.ClickOnPoint(info.HsHandle,
new Point((int)Helper.GetScaledXPos(Config.Instance.ExportClearX, info.HsRect.Width, info.Ratio),
(int)(Config.Instance.ExportClearY *info.HsRect.Height)));
if (count++ > 35)
{
break;
}
}
}
public static async Task <bool> Export(Deck deck, Func <Task <bool> > onInterrupt)
{
if (deck == null)
{
return(false);
}
var currentClipboard = "";
try
{
Log.Info("Exporting " + deck.GetDeckInfo());
if (Config.Instance.ExportPasteClipboard && Clipboard.ContainsText())
{
currentClipboard = Clipboard.GetText();
}
var info = new ExportingInfo();
LogDebugInfo(info);
info = await ExportingHelper.EnsureHearthstoneInForeground(info);
if (info == null)
{
return(false);
}
LogDebugInfo(info);
Log.Info($"Waiting for {Config.Instance.ExportStartDelay} seconds before starting the export process");
await Task.Delay(Config.Instance.ExportStartDelay *1000);
var exporter = new ExportingActions(info, deck, onInterrupt);
await exporter.ClearDeck();
await exporter.SetDeckName();
await exporter.ClearFilters();
await exporter.CreateDeck();
await exporter.ClearSearchBox();
if (Config.Instance.ExportPasteClipboard)
{
Clipboard.Clear();
}
Log.Info("Success exporting deck.");
return(true);
}
catch (ExportingInterruptedException e)
{
Log.Warn(e.Message);
return(false);
}
catch (Exception e)
{
Log.Error("Error exporting deck: " + e);
return(false);
}
finally
{
try
{
if (Config.Instance.ExportPasteClipboard && currentClipboard != "")
{
Clipboard.SetText(currentClipboard);
}
}
catch (Exception ex)
{
Log.Error("Could not restore clipboard content after export: " + ex);
}
}
}
public static async Task Export(Deck deck)
{
if (deck == null)
{
return;
}
var currentClipboard = "";
try
{
Logger.WriteLine("Exporting " + deck.GetDeckInfo(), "DeckExporter");
if (Config.Instance.ExportPasteClipboard && Clipboard.ContainsText())
{
currentClipboard = Clipboard.GetText();
}
var info = new ExportingInfo();
LogDebugInfo(info);
var inForeground = await ExportingHelper.EnsureHearthstoneInForeground(info.HsHandle);
if (!inForeground)
{
return;
}
Logger.WriteLine("Waiting for " + Config.Instance.ExportStartDelay + " seconds before starting the export process", "DeckExporter");
await Task.Delay(Config.Instance.ExportStartDelay * 1000);
Core.Overlay.ForceHide(true);
await ExportingActions.ClearDeck(info);
await ExportingActions.SetDeckName(deck, info);
await ExportingActions.ClearFilters(info);
var lostFocus = await ExportingActions.CreateDeck(deck, info);
if (lostFocus)
{
return;
}
await ExportingActions.ClearSearchBox(info.HsHandle, info.SearchBoxPos);
if (Config.Instance.ExportPasteClipboard)
{
Clipboard.Clear();
}
Logger.WriteLine("Success exporting deck.", "DeckExporter");
}
catch (Exception e)
{
Logger.WriteLine("Error exporting deck: " + e, "DeckExporter");
}
finally
{
Core.Overlay.ForceHide(false);
if (Config.Instance.ExportPasteClipboard && currentClipboard != "")
{
Clipboard.SetText(currentClipboard);
}
}
}
///<summary>
/// Returns -1 if Hearthstone loses focus
/// </summary>
public static async Task <int> AddCardToDeck(Card card, ExportingInfo info)
{
if (!User32.IsHearthstoneInForeground())
{
Core.MainWindow.ShowMessage("Exporting aborted", "Hearthstone window lost focus.");
Logger.WriteLine("Exporting aborted, window lost focus", "DeckExporter");
return(-1);
}
if (Config.Instance.ExportForceClear)
{
await ClearSearchBox(info.HsHandle, info.SearchBoxPos);
}
await MouseActions.ClickOnPoint(info.HsHandle, info.SearchBoxPos);
if (Config.Instance.ExportPasteClipboard)
{
Clipboard.SetText(ExportingHelper.GetSearchString(card));
SendKeys.SendWait("^v");
}
else
{
SendKeys.SendWait(ExportingHelper.GetSearchString(card));
}
SendKeys.SendWait("{ENTER}");
Logger.WriteLine("try to export card: " + card, "DeckExporter");
await Task.Delay(Config.Instance.DeckExportDelay * 2);
if (await ExportingHelper.CheckForSpecialCases(card, info.CardPosX + 50, info.Card2PosX + 50, info.CardPosY + 50, info.HsHandle))
{
return(0);
}
//Check if Card exist in collection
if (ExportingHelper.CardExists(info.HsHandle, (int)info.CardPosX, (int)info.CardPosY, info.HsRect.Width, info.HsRect.Height))
{
//Check if a golden exist
if (Config.Instance.PrioritizeGolden &&
ExportingHelper.CardExists(info.HsHandle, (int)info.Card2PosX, (int)info.CardPosY, info.HsRect.Width, info.HsRect.Height))
{
await MouseActions.ClickOnPoint(info.HsHandle, new Point((int)info.Card2PosX + 50, (int)info.CardPosY + 50));
if (card.Count == 2)
{
await MouseActions.ClickOnPoint(info.HsHandle, new Point((int)info.Card2PosX + 50, (int)info.CardPosY + 50));
await MouseActions.ClickOnPoint(info.HsHandle, new Point((int)info.CardPosX + 50, (int)info.CardPosY + 50));
}
}
else
{
await MouseActions.ClickOnPoint(info.HsHandle, new Point((int)info.CardPosX + 50, (int)info.CardPosY + 50));
if (card.Count == 2)
{
//Check if two card are not available
await Task.Delay(200 - Config.Instance.DeckExportDelay);
if (ExportingHelper.CardHasLock(info.HsHandle, (int)(info.CardPosX + info.HsRect.Width * 0.048),
(int)(info.CardPosY + info.HsRect.Height * 0.287), info.HsRect.Width, info.HsRect.Height))
{
if (ExportingHelper.CardExists(info.HsHandle, (int)info.Card2PosX, (int)info.CardPosY, info.HsRect.Width, info.HsRect.Height))
{
await MouseActions.ClickOnPoint(info.HsHandle, new Point((int)info.Card2PosX + 50, (int)info.CardPosY + 50));
return(0);
}
Logger.WriteLine("Only one copy found: " + card.Name, "DeckExporter");
return(1);
}
await MouseActions.ClickOnPoint(info.HsHandle, new Point((int)info.CardPosX + 50, (int)info.CardPosY + 50));
}
}
}
else
{
return(card.Count);
}
return(0);
}
public static async Task <bool> Export(Deck deck)
{
if (deck == null)
{
return(false);
}
var currentClipboard = "";
var altScreenCapture = Config.Instance.AlternativeScreenCapture;
try
{
Log.Info("Exporting " + deck.GetDeckInfo());
if (Config.Instance.ExportPasteClipboard && Clipboard.ContainsText())
{
currentClipboard = Clipboard.GetText();
}
var info = new ExportingInfo();
LogDebugInfo(info);
var inForeground = await ExportingHelper.EnsureHearthstoneInForeground(info.HsHandle);
if (!inForeground)
{
return(false);
}
Log.Info($"Waiting for {Config.Instance.ExportStartDelay} seconds before starting the export process");
await Task.Delay(Config.Instance.ExportStartDelay * 1000);
if (!altScreenCapture)
{
Core.Overlay.ForceHide(true);
}
await ClearDeck(info);
await SetDeckName(deck, info);
await ClearFilters(info);
var lostFocus = await CreateDeck(deck, info);
if (lostFocus)
{
return(false);
}
await ClearSearchBox(info.HsHandle, info.SearchBoxPos);
if (Config.Instance.ExportPasteClipboard)
{
Clipboard.Clear();
}
Log.Info("Success exporting deck.");
return(true);
}
catch (Exception e)
{
Log.Error("Error exporting deck: " + e);
return(false);
}
finally
{
if (!altScreenCapture)
{
Core.Overlay.ForceHide(false);
}
if (Config.Instance.ExportPasteClipboard && currentClipboard != "")
{
Clipboard.SetText(currentClipboard);
}
}
}
