From a929ec1418693575a092bf6510624fd4562180e4 Mon Sep 17 00:00:00 2001
From: Rembound <rembound@users.noreply.github.com>
Date: Sun, 28 Aug 2016 15:16:38 +0200
Subject: [PATCH] Changes for v0.8.1

---
 ArenaHelper.csproj |   8 +
 ArenaWindow.xaml   |   4 +-
 AutoUpdater.cs     | 106 ++++++
 Debug.cs           |  40 ++
 Detection.cs       | 456 +++++++++++++++++++++++
 Plugin.cs          | 900 ++++++++++-----------------------------------
 Update.cs          |  34 +-
 7 files changed, 824 insertions(+), 724 deletions(-)
 create mode 100644 AutoUpdater.cs
 create mode 100644 Debug.cs
 create mode 100644 Detection.cs

diff --git a/ArenaHelper.csproj b/ArenaHelper.csproj
index 8a99e11..ab0a419 100644
--- a/ArenaHelper.csproj
+++ b/ArenaHelper.csproj
@@ -36,6 +36,10 @@
     <Reference Include="Emgu.Util">
       <HintPath>..\..\..\..\CSharp\EmguCV3.0.0.2157\bin\Emgu.Util.dll</HintPath>
     </Reference>
+    <Reference Include="HearthMirror">
+      <HintPath>..\..\..\..\..\..\Software\Games\Hearthstone Deck Tracker\HearthMirror.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="Hearthstone Deck Tracker">
       <HintPath>..\..\..\..\..\..\Software\Games\Hearthstone Deck Tracker\Hearthstone Deck Tracker.exe</HintPath>
       <Private>False</Private>
@@ -52,6 +56,7 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Drawing" />
+    <Reference Include="System.IO.Compression.FileSystem" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Windows.Interactivity">
       <HintPath>packages\MahApps.Metro.1.1.2.0\lib\net45\System.Windows.Interactivity.dll</HintPath>
@@ -69,6 +74,7 @@
     <Compile Include="ArenaWindow.xaml.cs">
       <DependentUpon>ArenaWindow.xaml</DependentUpon>
     </Compile>
+    <Compile Include="AutoUpdater.cs" />
     <Compile Include="Controls\AdviceOverlay.xaml.cs">
       <DependentUpon>AdviceOverlay.xaml</DependentUpon>
     </Compile>
@@ -85,6 +91,8 @@
     <Compile Include="Controls\ValueOverlay.xaml.cs">
       <DependentUpon>ValueOverlay.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Debug.cs" />
+    <Compile Include="Detection.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Plugins.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
diff --git a/ArenaWindow.xaml b/ArenaWindow.xaml
index f887de4..27cffe2 100644
--- a/ArenaWindow.xaml
+++ b/ArenaWindow.xaml
@@ -72,10 +72,10 @@
             <!-- Update -->
             <controls:Flyout x:Name="FlyoutUpdate" Header="Update available!" CloseButtonVisibility="Collapsed" Position="Left" Width="400">
                 <StackPanel Margin="5">
-                    <TextBlock Margin="10,5,10,15" FontWeight="SemiBold" FontSize="13" TextWrapping="Wrap">
+                    <TextBlock x:Name="UpdateText" Margin="10,5,10,15" FontWeight="SemiBold" FontSize="13" TextWrapping="Wrap">
                         <Run Text="Press &quot;download&quot; to automatically download and install the new update. This will restart Hearthstone Deck Tracker." />
                     </TextBlock>
-                    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
+                    <StackPanel x:Name="UpdateButtons" Orientation="Horizontal" HorizontalAlignment="Center">
                         <Button Name="UpdateDownload" Content="download" Width="70" Margin="0,0,0,0" Height="30" Style="{DynamicResource AccentedSquareButtonStyle}" Click="UpdateDownload_Click"/>
                         <Button Name="UpdateWebsite" Content="website" Margin="10,0,0,0" Width="70" Height="30" Style="{DynamicResource SquareButtonStyle}" Click="UpdateWebsite_Click"/>
                         <Button Name="UpdateClose" Content="close" Width="70" Margin="10,0,0,0" Height="30" Style="{DynamicResource SquareButtonStyle}" Click="UpdateClose_Click"/>
diff --git a/AutoUpdater.cs b/AutoUpdater.cs
new file mode 100644
index 0000000..6c30c4e
--- /dev/null
+++ b/AutoUpdater.cs
@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Net;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Diagnostics;
+using Hearthstone_Deck_Tracker;
+using Hearthstone_Deck_Tracker.Utility.Logging;
+
+namespace ArenaHelper
+{
+    class AutoUpdater
+    {
+        private static string TempDir = Path.Combine(Config.AppDataPath, "ArenaHelperTemp");
+        private static string TempPluginDir = Path.Combine(Config.AppDataPath, "ArenaHelperTemp", "ArenaHelper");
+        private static string TargetPluginDir = Path.Combine(Config.AppDataPath, "Plugins", "ArenaHelper");
+
+        public const string userAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)";
+
+        public static async Task<bool> Update(string url)
+        {
+            bool status = true;
+            try
+            {
+                // Get filename of url
+                string filename = "update.zip";
+                Uri uri = new Uri(url);
+                if (uri.IsFile)
+                {
+                    filename = System.IO.Path.GetFileName(uri.LocalPath);
+                }
+                string filepath = Path.Combine(TempDir, filename);
+
+                // Make sure temp directory exists
+                Log.Info("Creating temporary directory");
+                if (Directory.Exists(TempDir))
+                    Directory.Delete(TempDir, true);
+                Directory.CreateDirectory(TempDir);
+
+                // Download the file
+                using (var wc = new WebClient())
+                {
+                    wc.Headers.Add("user-agent", userAgent);
+
+                    var lockobj = new object();
+                    Log.Info("Downloading latest version of Arena Helper... ");
+                    await wc.DownloadFileTaskAsync(url, filepath);
+                }
+
+                // Extract file
+                Log.Info("Extracting files...");
+                ZipFile.ExtractToDirectory(filepath, TempDir);
+
+                // Copy files
+                CopyFiles(TempDir, TempPluginDir, TargetPluginDir);
+            }
+            catch
+            {
+                status = false;
+            }
+            finally
+            {
+                try
+                {
+                    // Delete temp directory
+                    if (Directory.Exists(TempDir))
+                        Directory.Delete(TempDir, true);
+
+                    Log.Info("Update installed successfully!");
+                }
+                catch
+                {
+                    Log.Info("Could not delete temporary directory");
+                }
+            }
+            return status;
+        }
+
+        private static void CopyFiles(string dir, string newpath, string targetpath)
+        {
+            Log.Info("CopyFiles dir: " + dir);
+            Log.Info("CopyFiles newpath: " + newpath);
+            Log.Info("CopyFiles targetpath: " + targetpath);
+            foreach (var subdir in Directory.GetDirectories(dir))
+            {
+                var newdir = subdir.Replace(newpath, targetpath);
+                if (!Directory.Exists(newdir))
+                    Directory.CreateDirectory(newdir);
+
+                foreach (var file in Directory.GetFiles(subdir))
+                {
+                    // Write file
+                    var newfilepath = file.Replace(newpath, targetpath);
+                    Log.Info("Writing " + newfilepath);
+                    File.Copy(file, newfilepath, true);
+                }
+
+                // Recurse into subdir
+                CopyFiles(subdir, newpath, targetpath);
+            }
+        }
+    }
+}
diff --git a/Debug.cs b/Debug.cs
new file mode 100644
index 0000000..e6af669
--- /dev/null
+++ b/Debug.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ArenaHelper
+{
+    public static class Debug
+    {
+        public static Controls.DebugTextBlock debugtext = null;
+        public static List<System.Windows.Controls.Image> debugimages = null;
+
+        public static void SetTextControl(Controls.DebugTextBlock control)
+        {
+            debugtext = control;
+        }
+
+        public static void SetImageControls(List<System.Windows.Controls.Image> controls)
+        {
+            debugimages = controls;
+        }
+
+        public static void Log(string msg)
+        {
+            if (debugtext != null)
+            {
+                debugtext.Text = msg;
+            }
+        }
+
+        public static void AppendLog(string msg)
+        {
+            if (debugtext != null)
+            {
+                debugtext.Text += msg;
+            }
+        }
+    }
+}
diff --git a/Detection.cs b/Detection.cs
new file mode 100644
index 0000000..54d27c9
--- /dev/null
+++ b/Detection.cs
@@ -0,0 +1,456 @@
+using Hearthstone_Deck_Tracker;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Hearthstone_Deck_Tracker.Utility.Logging;
+using Emgu.CV;
+using Emgu.CV.Structure;
+
+namespace ArenaHelper
+{
+    public class Detection
+    {
+        private const int maxcarddistance = 10;
+        private const int maxherodistance = 14;
+
+        // Arena detection
+        public static Rectangle arenarect = new Rectangle(305, 0, 349, 69);
+        public static ulong arenahash = 14739256890895383027;
+        public static ulong arenahash2 = 18342314164188135155; // Dark arena hash in PluginState.DetectedHeroes
+
+        // Left card dimensions
+        public static int scalewidth = 1280;
+        public static int scaleheight = 960;
+        public static Rectangle cardrect = new Rectangle(100, 152, 260, 393);
+        public static Rectangle cardcroprect = new Rectangle(127, 226, 204, 157);
+        public static int cardwidth = 250;
+
+        // Portrait detection
+        public static Rectangle portraitcroprect = new Rectangle(143, 321, 173, 107);
+        public static int portraitwidth = 250;
+
+        // Big portrait detection
+        Rectangle portraitbigcroprect = new Rectangle(381, 376, 471, 291);
+
+        public Bitmap fullcapture = null;
+
+        public class DetectedInfo
+        {
+            public int index;
+            public int confirmations;
+
+            public DetectedInfo(int index)
+            {
+                this.index = index;
+                confirmations = 0;
+            }
+
+            public void Confirm(int cindex)
+            {
+                if (index != cindex)
+                {
+                    // Different index
+                    index = cindex;
+                    confirmations = 0;
+                }
+                else
+                {
+                    // Same index, increase confirmations
+                    confirmations++;
+                }
+            }
+        }
+
+        public int GetUndetectedCount(List<int> indices)
+        {
+            int undetected = 0;
+            for (int i = 0; i < indices.Count; i++)
+            {
+                if (indices[i] == -1)
+                {
+                    undetected++;
+                }
+            }
+            return undetected;
+        }
+
+        public int ConfirmDetected(List<DetectedInfo> detected, List<int> indices, int confirmations)
+        {
+            int confirmed = 0;
+            for (int i = 0; i < detected.Count; i++)
+            {
+                detected[i].Confirm(indices[i]);
+
+                if (detected[i].index != -1 && detected[i].confirmations >= confirmations)
+                {
+                    confirmed++;
+                }
+            }
+            return confirmed;
+        }
+
+        public Tuple<List<int>, List<Tuple<ulong, List<Tuple<int, int>>>>> DetectCards(IEnumerable<Plugin.HashData> cardhashlist)
+        {
+            // [cardhash, [cardindex, hashdistance]]
+            List<Tuple<ulong, List<Tuple<int, int>>>> detected = new List<Tuple<ulong, List<Tuple<int, int>>>>();
+            List<int> indices = new List<int>();
+
+            for (int i = 0; i < 3; i++)
+            {
+                ulong cardhash = GetScreenCardHash(i);
+                List<Tuple<int, int>> cardindices = FindHashIndex(cardhash, cardhashlist, maxcarddistance);
+
+                if (cardindices.Count == 1)
+                {
+                    indices.Add(cardindices[0].Item1);
+                }
+                else
+                {
+                    indices.Add(-1);
+                }
+
+                detected.Add(new Tuple<ulong, List<Tuple<int, int>>>(cardhash, cardindices));
+            }
+
+            return new Tuple<List<int>, List<Tuple<ulong, List<Tuple<int, int>>>>>(indices, detected);
+        }
+
+        public Tuple<List<int>, List<Tuple<ulong, List<Tuple<int, int>>>>> DetectHeroes(IEnumerable<Plugin.HeroHashData> herohashlist)
+        {
+            // [herohash, [heroindex, hashdistance]]
+            List<Tuple<ulong, List<Tuple<int, int>>>> detected = new List<Tuple<ulong, List<Tuple<int, int>>>>();
+            List<int> indices = new List<int>();
+
+            for (int i = 0; i < 3; i++)
+            {
+                ulong herohash = GetScreenHeroHash(i);
+                List<Tuple<int, int>> heroindices = FindHashIndex(herohash, herohashlist, maxherodistance);
+
+                if (heroindices.Count == 1)
+                {
+                    indices.Add(heroindices[0].Item1);
+                }
+                else
+                {
+                    indices.Add(-1);
+                }
+
+                detected.Add(new Tuple<ulong, List<Tuple<int, int>>>(herohash, heroindices));
+            }
+
+            return new Tuple<List<int>,List<Tuple<ulong,List<Tuple<int,int>>>>>(indices, detected);
+        }
+
+        public Tuple<List<int>, List<Tuple<ulong, List<Tuple<int, int>>>>> DetectBigHero(IEnumerable<Plugin.HeroHashData> herohashlist)
+        {
+            // [bigherohash, [heroindex, hashdistance]]
+            List<Tuple<ulong, List<Tuple<int, int>>>> detected = new List<Tuple<ulong, List<Tuple<int, int>>>>();
+            List<int> indices = new List<int>();
+
+            ulong bigherohash = GetScreenHash(portraitbigcroprect, scalewidth, scaleheight);
+            List<Tuple<int, int>> bigheroindices = FindHashIndex(bigherohash, herohashlist, maxherodistance);
+            if (bigheroindices.Count == 1)
+            {
+                indices.Add(bigheroindices[0].Item1);
+            }
+            else
+            {
+                indices.Add(-1);
+            }
+
+            detected.Add(new Tuple<ulong, List<Tuple<int, int>>>(bigherohash, bigheroindices));
+
+            return new Tuple<List<int>, List<Tuple<ulong, List<Tuple<int, int>>>>>(indices, detected);
+        }
+
+        public ulong GetScreenCardHash(int index)
+        {
+            // Check for a valid index
+            if (index < 0 || index >= 3)
+                return 0;
+
+            var hsrect = Helper.GetHearthstoneRect(false);
+
+            // Get the position and size of the card
+            Point cardpos = GetHSPos(hsrect, index * cardwidth + cardrect.X, cardrect.Y, scalewidth, scaleheight);
+            Point cardsize = GetHSSize(hsrect, cardrect.Width, cardrect.Height, scalewidth, scaleheight);
+
+            // Copy a part of the screen
+            Bitmap capture = fullcapture.Clone(new Rectangle(cardpos.X, cardpos.Y, cardsize.X, cardsize.Y), fullcapture.PixelFormat);
+
+            ulong hash = 0;
+            if (capture != null)
+            {
+                try
+                {
+                    CropBitmapRelative(ref capture, cardrect, cardcroprect);
+
+                    System.Windows.Controls.Image imagecontrol = Debug.debugimages[index];
+                    hash = GetImageHash(capture, ref imagecontrol);
+                }
+                catch (Exception e)
+                {
+                    string errormsg = "Error2: " + e.Message + "\n" + e.ToString();
+                    Debug.Log(errormsg);
+                    Log.Info(errormsg);
+                }
+            }
+
+            return hash;
+        }
+
+        public ulong GetScreenHeroHash(int index)
+        {
+            // Check for a valid index
+            if (index < 0 || index >= 3)
+                return 0;
+
+            var hsrect = Helper.GetHearthstoneRect(false);
+
+            // Get the position and size
+            Point pos = GetHSPos(hsrect, index * portraitwidth + portraitcroprect.X, portraitcroprect.Y, scalewidth, scaleheight);
+            Point size = GetHSSize(hsrect, portraitcroprect.Width, portraitcroprect.Height, scalewidth, scaleheight);
+
+            // Copy a part of the screen
+            Bitmap capture = fullcapture.Clone(new Rectangle(pos.X, pos.Y, size.X, size.Y), fullcapture.PixelFormat);
+
+            ulong hash = 0;
+            if (capture != null)
+            {
+                try
+                {
+                    System.Windows.Controls.Image imagecontrol = Debug.debugimages[index];
+                    hash = GetImageHash(capture, ref imagecontrol);
+                }
+                catch (Exception e)
+                {
+                    string errormsg = "Error3: " + e.Message + "\n" + e.ToString();
+                    Debug.Log(errormsg);
+                    Log.Info(errormsg);
+                }
+            }
+
+            return hash;
+        }
+
+        public ulong GetScreenHash(Rectangle rect, int scalewidth, int scaleheight)
+        {
+            ulong hash = 0;
+            var hsrect = Helper.GetHearthstoneRect(false);
+
+            // Get the position and size of the card
+            Point pos = GetHSPos(hsrect, rect.X, rect.Y, scalewidth, scaleheight);
+            Point size = GetHSSize(hsrect, rect.Width, rect.Height, scalewidth, scaleheight);
+
+            // Copy a part of the screen
+            Bitmap capture = fullcapture.Clone(new Rectangle(pos.X, pos.Y, size.X, size.Y), fullcapture.PixelFormat);
+
+            if (capture != null)
+            {
+                try
+                {
+                    System.Windows.Controls.Image imagecontrol = Debug.debugimages[0];
+                    hash = GetImageHash(capture, ref imagecontrol);
+                }
+                catch (Exception e)
+                {
+                    string errormsg = "Error4: " + e.Message + "\n" + e.ToString();
+                    Debug.Log(errormsg);
+                    Log.Info(errormsg);
+                }
+            }
+
+            return hash;
+        }
+
+        // Perceptual hash using the techniques from: http://www.hackerfactor.com/blog/?/archives/432-Looks-Like-It.html
+        public ulong GetImageHash(Bitmap bitmap, ref System.Windows.Controls.Image imagecontrol)
+        {
+            // Copy the image and convert to grayscale
+            Bitmap sourcebm = new Bitmap(bitmap);
+            Image<Gray, float> sourceimage = new Image<Gray, float>(sourcebm);
+
+            // Apply a convolution filter of 4x4
+            CvInvoke.Blur(sourceimage, sourceimage, new Size(4, 4), new Point(-1, -1));
+
+            // Show image for debugging
+            //Image<Bgra, Byte> convimage = Image<Bgra, Byte>.FromIplImagePtr(sourceimage);
+            //ShowBitmap(convimage.ToBitmap(), ref imagecontrol);
+
+            // Resize to 64x64 pixels
+            Image<Gray, float> resimage = new Image<Gray, float>(new Size(64, 64));
+            CvInvoke.Resize(sourceimage, resimage, new Size(64, 64));
+            //ShowBitmap(resimage.ToBitmap(), ref imagecontrol);
+
+            // DCT
+            IntPtr compleximage = CvInvoke.cvCreateImage(resimage.Size, Emgu.CV.CvEnum.IplDepth.IplDepth32F, 1);
+            CvInvoke.Dct(resimage, resimage, Emgu.CV.CvEnum.DctType.Forward);
+
+            Image<Gray, float> dctimage = Image<Gray, float>.FromIplImagePtr(resimage);
+
+            // Calculate the mean
+            double mean = 0;
+            for (int x = 0; x < 8; x++)
+            {
+                for (int y = 0; y < 8; y++)
+                {
+                    mean += dctimage[y, x].Intensity;
+                }
+            }
+            mean -= dctimage[0, 0].Intensity;
+            mean /= 63;
+
+            // Calculate the hash
+            ulong hash = 0;
+            ulong index = 1;
+            for (int x = 0; x < 8; x++)
+            {
+                for (int y = 0; y < 8; y++)
+                {
+                    Gray color = dctimage[y, x];
+                    if (color.Intensity > mean)
+                    {
+                        hash |= index;
+                        // For debugging
+                        //bitmap.SetPixel(x, y, Color.FromArgb(255, 0, 0));
+                    }
+                    else
+                    {
+                        // For debugging
+                        //bitmap.SetPixel(x, y, Color.FromArgb(0, 255, 0));
+                    }
+
+                    index <<= 1;
+                }
+            }
+
+            return hash;
+        }
+
+        public int GetHashDistance(ulong hash1, ulong hash2)
+        {
+            ulong index = 1;
+            int distance = 0;
+            for (int i = 0; i < 64; i++)
+            {
+                if ((hash1 & index) != (hash2 & index))
+                {
+                    distance++;
+                }
+
+                index <<= 1;
+            }
+
+            return distance;
+        }
+
+        public List<Tuple<int, int>> FindHashIndex(ulong hash, IEnumerable<Plugin.HashData> hashlist, int maxdistance)
+        {
+            int bestindex = -1;
+            int bestdistance = 100;
+
+            List<Tuple<int, int>> indices = new List<Tuple<int, int>>();
+            int i = 0;
+            foreach (var item in hashlist)
+            {
+                // Check all item hashes
+                foreach (var itemhash in item.hashes)
+                {
+                    int distance = GetHashDistance(hash, itemhash);
+                    if (distance < maxdistance)
+                    {
+                        if (distance < bestdistance)
+                        {
+                            bestindex = i;
+                            bestdistance = distance;
+
+                            indices.Clear();
+                            indices.Add(new Tuple<int, int>(i, distance));
+                        }
+                        else if (bestindex != i && distance == bestdistance)
+                        {
+                            // Collision
+                            indices.Add(new Tuple<int, int>(i, distance));
+                        }
+                    }
+                }
+                i++;
+            }
+
+            return indices;
+        }
+
+        public List<Tuple<int, int>> FindAllHashIndex(ulong hash, IList<Plugin.CardHashData> hashlist, int maxdistance)
+        {
+            List<Tuple<int, int>> indices = new List<Tuple<int, int>>();
+            for (var i = 0; i < hashlist.Count; i++)
+            {
+                // Check all item hashes
+                foreach (var itemhash in hashlist[i].hashes)
+                {
+                    int distance = GetHashDistance(hash, itemhash);
+                    if (distance < maxdistance)
+                    {
+                        indices.Add(new Tuple<int, int>(i, distance));
+                    }
+                }
+            }
+
+            return indices;
+        }
+
+        public void CropBitmapRelative(ref Bitmap bm, Rectangle fullrect, Rectangle croprect)
+        {
+            double cropx = (double)(croprect.X - fullrect.X) / fullrect.Width;
+            double cropy = (double)(croprect.Y - fullrect.Y) / fullrect.Height;
+            double cropwidth = (double)croprect.Width / fullrect.Width;
+            double cropheight = (double)croprect.Height / fullrect.Height;
+
+            bm = bm.Clone(new Rectangle((int)(cropx * bm.Width), (int)(cropy * bm.Height), (int)(cropwidth * bm.Width), (int)(cropheight * bm.Height)), bm.PixelFormat);
+        }
+
+        // Reference resolution: 1280 x 960 (4:3)
+        public static Point GetHSPos(Rectangle hsrect, int x, int y, int width, int height)
+        {
+            // Get normalized position
+            double nx = x / (double)width;
+            double ny = y / (double)height;
+
+            // Convert to actual position
+            double ratio = ((double)width / (double)height) / ((double)hsrect.Width / hsrect.Height);
+            int px = (int)((hsrect.Width * ratio * nx) + (hsrect.Width * (1 - ratio) / 2));
+            int py = (int)(ny * hsrect.Height);
+            return new Point(px, py);
+        }
+
+        // Doesn't work for too wide aspect ratios
+        public static Point GetHSSize(Rectangle hsrect, int x, int y, int width, int height)
+        {
+            double scalefactor = (double)hsrect.Height / height;
+
+            return new Point((int)(scalefactor * x), (int)(scalefactor * y));
+        }
+
+
+        // Doesn't work on some systems
+        /*private void ShowBitmap(Bitmap bm, ref System.Windows.Controls.Image imagecontrol)
+        {
+            if (imagecontrol != null)
+            {
+
+                MemoryStream ms = new MemoryStream();
+                bm.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
+                ms.Position = 0;
+                BitmapImage bi = new BitmapImage();
+                bi.BeginInit();
+                bi.StreamSource = ms;
+                bi.EndInit();
+
+                imagecontrol.Source = bi;
+            }
+        }*/
+    }
+}
diff --git a/Plugin.cs b/Plugin.cs
index 9462edb..71ccf5f 100644
--- a/Plugin.cs
+++ b/Plugin.cs
@@ -10,8 +10,6 @@
 using System.Reflection;
 using Hearthstone_Deck_Tracker;
 using Hearthstone_Deck_Tracker.Plugins;
-using Emgu.CV;
-using Emgu.CV.Structure;
 using Hearthstone_Deck_Tracker.Hearthstone;
 using System.Diagnostics;
 using System.Threading;
@@ -22,7 +20,7 @@
 using Newtonsoft.Json.Converters;
 using Hearthstone_Deck_Tracker.Utility;
 using Hearthstone_Deck_Tracker.Utility.Logging;
-
+using HearthMirror;
 
 namespace ArenaHelper
 {
@@ -112,33 +110,6 @@ public HeroHashData(int index, string name, string image, params ulong[] hashes)
             }
         }
 
-        public class DetectedInfo
-        {
-            public int index;
-            public int confirmations;
-
-            public DetectedInfo(int index)
-            {
-                this.index = index;
-                confirmations = 0;
-            }
-
-            public void Confirm(int cindex)
-            {
-                if (index != cindex)
-                {
-                    // Different index
-                    index = cindex;
-                    confirmations = 0;
-                }
-                else
-                {
-                    // Same index, increase confirmations
-                    confirmations++;
-                }
-            }
-        }
-
         public class ArenaData
         {
             public string deckname;
@@ -159,35 +130,11 @@ public ArenaData()
             }
         }
 
-        [StructLayout(LayoutKind.Sequential)]
-        private struct MousePoint
-        {
-            public readonly int X;
-            public readonly int Y;
-        }
-
-        [DllImport("user32.dll")]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        private static extern bool GetCursorPos(out MousePoint lpPoint);
-
-        public static Point GetMousePos()
-        {
-            MousePoint p;
-            GetCursorPos(out p);
-            return new Point(p.X, p.Y);
-        }
-
-        [DllImport("user32.dll")]
-        static extern short GetAsyncKeyState(UInt16 virtualKeyCode);
-        private const UInt16 VK_MBUTTON = 0x04; // middle mouse button
-        private const UInt16 VK_LBUTTON = 0x01; // left mouse button
-        private const UInt16 VK_RBUTTON = 0x02; // right mouse button
-
         public enum PluginState { Idle, SearchHeroes, SearchBigHero, DetectedHeroes, SearchCards, SearchCardValues, DetectedCards, Done };
 
-        private List<DetectedInfo> detectedcards = new List<DetectedInfo>();
-        private List<DetectedInfo> detectedheroes = new List<DetectedInfo>();
-        private List<DetectedInfo> detectedbighero = new List<DetectedInfo>();
+        private List<Detection.DetectedInfo> detectedcards = new List<Detection.DetectedInfo>();
+        private List<Detection.DetectedInfo> detectedheroes = new List<Detection.DetectedInfo>();
+        private List<Detection.DetectedInfo> detectedbighero = new List<Detection.DetectedInfo>();
         private static PluginState state;
         private List<int> mouseindex = new List<int>();
         private ArenaData arenadata = new ArenaData();
@@ -195,10 +142,10 @@ public enum PluginState { Idle, SearchHeroes, SearchBigHero, DetectedHeroes, Sea
         private ConfigData configdata = new ConfigData();
         private bool configinit = false;
 
-        private List<ArenaHelper.Controls.ValueOverlay> valueoverlays = new List<ArenaHelper.Controls.ValueOverlay>();
-        private ArenaHelper.Controls.AdviceOverlay adviceoverlay = null;
-        private ArenaHelper.Controls.DebugTextBlock testtext = null;
-        private List<System.Windows.Controls.Image> testimages = new List<System.Windows.Controls.Image>();
+        private List<Controls.ValueOverlay> valueoverlays = new List<Controls.ValueOverlay>();
+        private Controls.AdviceOverlay adviceoverlay = null;
+        private Controls.DebugTextBlock debugtext = null;
+        private List<System.Windows.Controls.Image> debugimages = new List<System.Windows.Controls.Image>();
 
         private Update.AHDataVersion dataversion;
         private const string DataVersionFile = "version.json";
@@ -209,19 +156,9 @@ public enum PluginState { Idle, SearchHeroes, SearchBigHero, DetectedHeroes, Sea
         public static List<HeroHashData> herohashlist = new List<HeroHashData>();
         public static List<CardTierInfo> cardtierlist = new List<CardTierInfo>();
 
-        private Bitmap fullcapture;
-
-        // Left card dimensions
-        private const int scalewidth = 1280;
-        private const int scaleheight = 960;
-        Rectangle cardrect = new Rectangle(100, 152, 260, 393);
-        Rectangle cardcroprect = new Rectangle(127, 226, 204, 157);
-        private const int cardwidth = 250;
+        private Detection detection = new Detection();
 
         // Arena detection
-        Rectangle arenarect = new Rectangle(305, 0, 349, 69);
-        ulong arenahash = 14739256890895383027;
-        ulong arenahash2 = 18342314164188135155; // Dark arena hash in PluginState.DetectedHeroes
         bool inarena = false;
         bool stablearena = false;
         Stopwatch arenastopwatch;
@@ -229,16 +166,7 @@ public enum PluginState { Idle, SearchHeroes, SearchBigHero, DetectedHeroes, Sea
         // Configure heroes
         bool configurehero = false;
 
-        // Portrait detection
-        Rectangle portraitcroprect = new Rectangle(143, 321, 173, 107);
-        private const int portraitwidth = 250;
-        ulong[] herohashes = new ulong[7];
-
-        // Big portrait detection
-        Rectangle portraitbigcroprect = new Rectangle(381, 376, 471, 291);
-
         // Log reader
-        private bool uselogreader = true;
         private DateTime loglasttime = DateTime.MinValue;
         private string loglastline = "";
         private DateTime loglastchoice = DateTime.MinValue;
@@ -247,6 +175,9 @@ public enum PluginState { Idle, SearchHeroes, SearchBigHero, DetectedHeroes, Sea
         //"DraftManager.OnChosen(): hero=HERO_03 premium=STANDARD"
         public static readonly Regex HeroChosenRegex = new Regex(@"DraftManager\.OnChosen\(\): hero=(?<id>(.+)) .*");
 
+        // HearthMirror
+        private bool usehearthmirror = true;
+
         // Updates
         private DateTime lastpluginupdatecheck = DateTime.MinValue;
         private Update.GithubRelease latestrelease = null;
@@ -260,7 +191,7 @@ public enum PluginState { Idle, SearchHeroes, SearchBigHero, DetectedHeroes, Sea
         Stopwatch stopwatch;
 
         protected MenuItem MainMenuItem { get; set; }
-        protected static ArenaWindow arenawindow;
+        internal static ArenaWindow arenawindow = null;
         
         private SemaphoreSlim mutex = new SemaphoreSlim(1);
 
@@ -269,8 +200,6 @@ public enum PluginState { Idle, SearchHeroes, SearchBigHero, DetectedHeroes, Sea
         private const int HeroConfirmations = 3;
         private const int CardConfirmations = 3;
         private const int BigHeroConfirmations = 0; // Confirm immediately
-        private const int maxcarddistance = 10;
-        private const int maxherodistance = 14;
         private const string DetectingArena = "Detecting arena...";
         private const string DetectingHeroes = "Detecting heroes...";
         private const string DetectingCards = "Detecting cards...";
@@ -279,8 +208,6 @@ public enum PluginState { Idle, SearchHeroes, SearchBigHero, DetectedHeroes, Sea
         private const string DoneMessage = "All cards are picked. You can start a new arena run or save the deck.";
         private const string ConfigFile = "arenahelper.json";
 
-        // TODO: When AH window is open, and you start Hearthstone, sometimes the plugin takes too long and gets suspended.
-
         private Plugins plugins = new Plugins();
 
         private string DataDir
@@ -320,7 +247,7 @@ public string Author
 
         public Version Version
         {
-            get { return new Version("0.8.0"); }
+            get { return new Version("0.8.1"); }
         }
 
         public MenuItem MenuItem
@@ -332,9 +259,6 @@ public void OnLoad()
         {
             try
             {
-                // Clean auto updater
-                Update.CleanAutoUpdate();
-
                 // Load plugins
                 plugins.LoadPlugins();
 
@@ -343,7 +267,7 @@ public void OnLoad()
                 // Set hashes
                 herohashlist.Clear();
                 herohashlist.Add(new HeroHashData(0, "Warrior", "warrior_small.png", 13776678289873991291, 10236917153841177209, 15929423101315404409, 13071189497635732127, 13237968094529645459)); // Garrosh, Garrosh golden small, Garrosh golden big, Magni small, Magni big
-                herohashlist.Add(new HeroHashData(1, "Shaman", "shaman_small.png", 18366959783178990451));
+                herohashlist.Add(new HeroHashData(1, "Shaman", "shaman_small.png", 18366959783178990451, 15841665550811421911, 15769608231248747991)); // Thrall, Morgl small, Morgl big
                 herohashlist.Add(new HeroHashData(2, "Rogue", "rogue_small.png", 5643619427529904809, 11263619176753353643, 10111770795730096795)); // Valeera, Valeera golden small, Valeera golden big
                 herohashlist.Add(new HeroHashData(3, "Paladin", "paladin_small.png", 11505795398351105139, 11848119152778072427, 11846995451926976873)); // Uther Lightbringer, Lady Liadrin small, Lady Liadrin big
                 herohashlist.Add(new HeroHashData(4, "Hunter", "hunter_small.png", 2294799430464257123, 1975465933826505957, 813537221374590069, 12942361696967163803, 17552924014479703963)); // Rexxar, Rexxar golden small, Rexxar golden big, Alleria small, Alleria big
@@ -401,6 +325,9 @@ private void ActivateArenaWindow()
                     // Show about page when auto updated
                     if (configdata.updated)
                     {
+                        // Clean auto updater
+                        Update.CleanAutoUpdate();
+
                         arenawindow.FlyoutAbout.IsOpen = true;
                         configdata.updated = false;
                         SaveConfig();
@@ -546,11 +473,11 @@ private void ApplyConfig()
             // Debug
             if (configdata.debug)
             {
-                testtext.Visibility = System.Windows.Visibility.Visible;
+                debugtext.Visibility = System.Windows.Visibility.Visible;
             }
             else
             {
-                testtext.Visibility = System.Windows.Visibility.Hidden;
+                debugtext.Visibility = System.Windows.Visibility.Hidden;
             }
         }
 
@@ -706,14 +633,34 @@ public void OnWindowLocation()
         }
 
         // Auto update
-        public void OnUpdateDownloadClick()
+        public async void OnUpdateDownloadClick()
         {
             Log.Info("Auto Updating Arena Helper");
             if (latestrelease != null)
             {
+                arenawindow.UpdateText.Text = "Updating Arena Helper, please wait...";
+                arenawindow.UpdateButtons.Visibility = System.Windows.Visibility.Hidden;
                 configdata.updated = true;
                 SaveConfig();
-                Update.AutoUpdate(latestrelease);
+
+                // Update
+                bool status = await Update.AutoUpdate(latestrelease);
+                if (status)
+                {
+                    // Start the new process
+                    Process.Start(System.Windows.Application.ResourceAssembly.Location);
+
+                    // Shutdown the old process
+                    Hearthstone_Deck_Tracker.API.Core.MainWindow.Close();
+                    System.Windows.Application.Current.Shutdown();
+                }
+                else
+                {
+                    arenawindow.UpdateText.Text = "There was a problem while auto-updating. Press \"website\" to visit the project page and update manually.";
+
+                    arenawindow.UpdateDownload.IsEnabled = false;
+                    arenawindow.UpdateButtons.Visibility = System.Windows.Visibility.Visible;
+                }
             }
         }
 
@@ -946,17 +893,17 @@ private void NewArena()
         private void ClearDetected()
         {
             detectedcards.Clear();
-            detectedcards.Add(new DetectedInfo(-1));
-            detectedcards.Add(new DetectedInfo(-1));
-            detectedcards.Add(new DetectedInfo(-1));
+            detectedcards.Add(new Detection.DetectedInfo(-1));
+            detectedcards.Add(new Detection.DetectedInfo(-1));
+            detectedcards.Add(new Detection.DetectedInfo(-1));
 
             detectedheroes.Clear();
-            detectedheroes.Add(new DetectedInfo(-1));
-            detectedheroes.Add(new DetectedInfo(-1));
-            detectedheroes.Add(new DetectedInfo(-1));
+            detectedheroes.Add(new Detection.DetectedInfo(-1));
+            detectedheroes.Add(new Detection.DetectedInfo(-1));
+            detectedheroes.Add(new Detection.DetectedInfo(-1));
 
             detectedbighero.Clear();
-            detectedbighero.Add(new DetectedInfo(-1));
+            detectedbighero.Add(new Detection.DetectedInfo(-1));
         }
 
         public void OnUnload()
@@ -997,7 +944,7 @@ public async void OnUpdate()
             {
                 if (arenawindow != null && state != PluginState.Done)
                 {
-                    testtext.Text = "";
+                    Debug.Log("");
                     stopwatch.Restart();
 
                     // Size updates
@@ -1007,28 +954,21 @@ public async void OnUpdate()
                     var hsrect = Helper.GetHearthstoneRect(false);
                     if (hsrect.Width > 0 && hsrect.Height > 0)
                     {
-                        bool needsfocus = true;
-                        if (configdata.manualclicks || uselogreader)
-                        {
-                            // With manual clicks or logreader, we don't need the focus
-                            needsfocus = false;
-                        }
-
-                        if (needsfocus && !User32.IsHearthstoneInForeground())
+                        if (Config.Instance.AlternativeScreenCapture)
                         {
-                            fullcapture = null;
+                            detection.fullcapture = ScreenCapture.CaptureWindow(User32.GetHearthstoneWindow(), new Point(0, 0), hsrect.Width, hsrect.Height);
                         }
                         else
                         {
-                            fullcapture = ScreenCapture.CaptureScreen(User32.GetHearthstoneWindow(), new Point(0, 0), hsrect.Width, hsrect.Height);
+                            detection.fullcapture = ScreenCapture.CaptureScreen(User32.GetHearthstoneWindow(), new Point(0, 0), hsrect.Width, hsrect.Height);
                         }
                     }
                     else
                     {
-                        fullcapture = null;
+                        detection.fullcapture = null;
                     }
 
-                    if (fullcapture != null)
+                    if (detection.fullcapture != null)
                     {
                         await Detect();
                     }
@@ -1040,7 +980,7 @@ public async void OnUpdate()
                         SetState(state);
                     }
 
-                    testtext.Text += "\nElapsed: " + stopwatch.ElapsedMilliseconds;
+                    Debug.AppendLog("\nElapsed: " + stopwatch.ElapsedMilliseconds);
                 }
             }
             catch (Exception e)
@@ -1157,14 +1097,14 @@ private void UpdateSize()
             // Position card values
             for (int i = 0; i < valueoverlays.Count; i++)
             {
-                Point cardpos = GetHSPos(hsrect, i * cardwidth + cardrect.X, cardrect.Y, scalewidth, scaleheight);
-                Point cardsize = GetHSSize(hsrect, cardrect.Width, cardrect.Height - 8, scalewidth, scaleheight);
+                Point cardpos = Detection.GetHSPos(hsrect, i * Detection.cardwidth + Detection.cardrect.X, Detection.cardrect.Y, Detection.scalewidth, Detection.scaleheight);
+                Point cardsize = Detection.GetHSSize(hsrect, Detection.cardrect.Width, Detection.cardrect.Height - 8, Detection.scalewidth, Detection.scaleheight);
 
                 Canvas.SetLeft(valueoverlays[i], cardpos.X + cardsize.X / 2 - valueoverlays[i].RenderSize.Width/2);
                 Canvas.SetTop(valueoverlays[i], cardpos.Y + cardsize.Y);
             }
 
-            Point advpos = GetHSPos(hsrect, cardrect.X, cardrect.Y + cardrect.Height - 8, scalewidth, scaleheight);
+            Point advpos = Detection.GetHSPos(hsrect, Detection.cardrect.X, Detection.cardrect.Y + Detection.cardrect.Height - 8, Detection.scalewidth, Detection.scaleheight);
             //Point advsize = GetHSSize(hsrect, cardrect.Width, cardrect.Height, scalewidth, scaleheight);
             Canvas.SetLeft(adviceoverlay, advpos.X);
             Canvas.SetTop(adviceoverlay, advpos.Y + 52);
@@ -1235,8 +1175,6 @@ private async Task CheckDataUpdate()
                     Update.AHDataVersion latestdataversion = await Update.GetDataVersion();
                     if (latestdataversion != null)
                     {
-                        string assemblylocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
-
                         if (latestdataversion.hashlist > dataversion.hashlist)
                         {
                             // Hash list updated, download the new hash list
@@ -1392,24 +1330,24 @@ private async Task Detect()
             try
             {
                 // Detect arena
-                ulong arenascreenhash = GetScreenHash(arenarect, scalewidth, scaleheight);
+                ulong arenascreenhash = detection.GetScreenHash(Detection.arenarect, Detection.scalewidth, Detection.scaleheight);
 
                 // Screen is darker when picking a hero
                 bool arenacheck2 = false;
 
                 if (state == PluginState.DetectedHeroes || state == PluginState.SearchBigHero)
                 {
-                    if (GetHashDistance(arenahash2, arenascreenhash) < 10)
+                    if (detection.GetHashDistance(Detection.arenahash2, arenascreenhash) < 10)
                     {
                         arenacheck2 = true;
-                        testtext.Text += "Arenacheck2 true\n";
+                        Debug.AppendLog("Arenacheck2 true\n");
                     }
                 }
-                testtext.Text += "Arenacheck1: " + GetHashDistance(arenahash, arenascreenhash) + "\n";
-                testtext.Text += "Arenacheck2: " + GetHashDistance(arenahash2, arenascreenhash) + "\n";
+                Debug.AppendLog("Arenacheck1: " + detection.GetHashDistance(Detection.arenahash, arenascreenhash) + "\n");
+                Debug.AppendLog("Arenacheck2: " + detection.GetHashDistance(Detection.arenahash2, arenascreenhash) + "\n");
 
 
-                if (GetHashDistance(arenahash, arenascreenhash) < 10 || arenacheck2)
+                if (detection.GetHashDistance(Detection.arenahash, arenascreenhash) < 10 || arenacheck2)
                 {
                     // In arena
                     // If previously not in arena, wait for stable arena screen
@@ -1447,24 +1385,55 @@ private async Task Detect()
 
                 // In arena
 
-                // Detect heroes and cards
-                List<int> heroindices = DetectHeroes();
-                List<int> cardindices = DetectCards();
+                // Detect heroes
+                Tuple<List<int>, List<Tuple<ulong, List<Tuple<int, int>>>>> detectedheroes = detection.DetectHeroes(herohashlist);
+                List<int> heroindices = detectedheroes.Item1;
+
+                // Show debug info
+                for (int i = 0; i < detectedheroes.Item2.Count; i++)
+                {
+                    ulong herohash = detectedheroes.Item2[i].Item1;
+                    List<Tuple<int, int>> detectedindices = detectedheroes.Item2[i].Item2;
+
+                    Debug.AppendLog("\nHero Hash" + i + ": " + string.Format("0x{0:X}", herohash));
+                    foreach (Tuple<int, int> heroindex in detectedindices)
+                    {
+                        Debug.AppendLog(", " + herohashlist[heroindex.Item1].name + " (" + heroindex.Item2 + ")");
+                    }
+                }
+
+                // Detect cards
+                Tuple<List<int>, List<Tuple<ulong, List<Tuple<int, int>>>>> detectedcards = detection.DetectCards(cardhashlist);
+                List<int> cardindices = detectedcards.Item1;
+
+                // Show debug info
+                for (int i = 0; i < detectedcards.Item2.Count; i++)
+                {
+                    ulong cardhash = detectedcards.Item2[i].Item1;
+                    List<Tuple<int, int>> detectedindices = detectedcards.Item2[i].Item2;
+
+                    Debug.AppendLog("\nHash" + i + ": " + string.Format("0x{0:X}", cardhash));
+                    foreach (Tuple<int, int> cardindex in detectedindices)
+                    {
+                        Debug.AppendLog(", " + cardlist[cardindex.Item1].Name + " (" + cardindex.Item2 + ")");
+                    }
+                }
+
 
                 if (state == PluginState.SearchHeroes)
                 {
                     // Searching for heroes
-                    SearchHeroes(heroindices, cardindices);
+                    SearchHeroes(heroindices);
                 }
                 else if (state == PluginState.SearchBigHero)
                 {
                     // Heroes detected, searching for big hero selection
-                    SearchBigHero(heroindices, cardindices);
+                    SearchBigHero(heroindices);
                 }
                 else if (state == PluginState.DetectedHeroes)
                 {
                     // Heroes detected, waiting
-                    WaitHeroPick(heroindices, cardindices);
+                    WaitHeroPick(heroindices);
                 }
                 else if (state == PluginState.SearchCards)
                 {
@@ -1474,27 +1443,25 @@ private async Task Detect()
                 else if (state == PluginState.SearchCardValues)
                 {
                     // Get card values
-                    await SearchCardValues(cardindices);
+                    await SearchCardValues();
                 }
                 else if (state == PluginState.DetectedCards)
                 {
                     // Cards detected, waiting
-                    WaitCardPick(cardindices);
+                    WaitCardPick();
                 }
             }
             catch (Exception e)
             {
-                if (testtext != null)
-                {
-                    testtext.Text = "Error: " + e.Message + "\n" + e.ToString();
-                }
+                Debug.Log("Error: " + e.Message + "\n" + e.ToString());
             }
-
         }
 
-        private void SearchHeroes(List<int> heroindices, List<int> cardindices)
+
+
+        private void SearchHeroes(List<int> heroindices)
         {
-            if (ConfirmDetected(detectedheroes, heroindices, HeroConfirmations) == 3)
+            if (detection.ConfirmDetected(detectedheroes, heroindices, HeroConfirmations) == 3)
             {
                 // All heroes detected
                 HeroHashData hero0 = herohashlist[detectedheroes[0].index];
@@ -1516,10 +1483,26 @@ private void SearchHeroes(List<int> heroindices, List<int> cardindices)
             }
         }
 
-        private void SearchBigHero(List<int> heroindices, List<int> cardindices)
+        private void SearchBigHero(List<int> heroindices)
         {
-            List<int> bigheroindices = DetectBigHero();
-            if (ConfirmDetected(detectedbighero, bigheroindices, BigHeroConfirmations) == 1)
+            Tuple<List<int>, List<Tuple<ulong, List<Tuple<int, int>>>>> detectedbigheroes = detection.DetectBigHero(herohashlist);
+            List<int> bigheroindices = detectedbigheroes.Item1;
+
+            // Show debug info
+            for (int i = 0; i < detectedbigheroes.Item2.Count; i++)
+            {
+                ulong bigherohash = detectedbigheroes.Item2[i].Item1;
+                List<Tuple<int, int>> detectedindices = detectedbigheroes.Item2[i].Item2;
+
+                Debug.AppendLog("\nBig Hero Hash: " + string.Format("0x{0:X}", bigherohash));
+                foreach (Tuple<int, int> bigheroindex in detectedindices)
+                {
+                    Debug.AppendLog(", " + herohashlist[bigheroindex.Item1].name + " (" + bigheroindex.Item2 + ")");
+                }
+                Debug.AppendLog("\n");
+            }
+
+            if (detection.ConfirmDetected(detectedbighero, bigheroindices, BigHeroConfirmations) == 1)
             {
                 // Big hero detected
 
@@ -1539,7 +1522,7 @@ private void SearchBigHero(List<int> heroindices, List<int> cardindices)
                 SetState(PluginState.DetectedHeroes);
 
                 // Call it immediately
-                WaitHeroPick(heroindices, cardindices);
+                WaitHeroPick(heroindices);
             }
         }
 
@@ -1585,12 +1568,12 @@ private void ChangeHeroSize(int index, int width, int height, int margin)
             arenawindow.Update();
         }
 
-        private void WaitHeroPick(List<int> heroindices, List<int> cardindices)
+        private void WaitHeroPick(List<int> heroindices)
         {
-            testtext.Text += "\nChoosing: " + herohashlist[detectedbighero[0].index].name + "\n";
+            Debug.AppendLog("\nChoosing: " + herohashlist[detectedbighero[0].index].name + "\n");
 
             // All heroes detected, wait for pick
-            if (GetUndetectedCount(heroindices) == 0)
+            if (detection.GetUndetectedCount(heroindices) == 0)
             {
                 // Cancelled the choice
                 ClearDetected();
@@ -1599,12 +1582,6 @@ private void WaitHeroPick(List<int> heroindices, List<int> cardindices)
                 // Restore gui
                 ResetHeroSize();
             }
-            else if (!uselogreader && GetUndetectedCount(heroindices) == 3 && GetUndetectedCount(cardindices) < 3)
-            {
-                // No heroes detected, at least one card detected
-                // The player picked a hero
-                PickHero(detectedbighero[0].index);
-            }
         }
 
         private void PickHero(int heroindex)
@@ -1625,30 +1602,57 @@ private void PickHero(int heroindex)
 
         private async Task SearchCards(List<int> cardindices)
         {
-            if (ConfirmDetected(detectedcards, cardindices, CardConfirmations) == 3)
+            // TODO: Using HearthMirror. Also has reference to HearthMirror.
+            Card[] cards = new Card[3];
+            bool valid = false;
+
+            if (usehearthmirror)
+            {
+                Log.Info("GetArenaDraftChoices");
+                List<HearthMirror.Objects.Card> choices = Reflection.GetArenaDraftChoices();
+                if (choices.Count == 3)
+                {
+                    for (int i = 0; i < 3; i++)
+                    {
+                        cards[i] = GetCard(choices[i].Id);
+                        Log.Info("Choice: " + choices[i].Id);
+                    }
+                    valid = true;
+                }
+            }
+            else if (detection.ConfirmDetected(detectedcards, cardindices, CardConfirmations) == 3)
             {
                 // All cards detected
 
                 // Save detected cards
-                Card card0 = cardlist[detectedcards[0].index];
-                Card card1 = cardlist[detectedcards[1].index];
-                Card card2 = cardlist[detectedcards[2].index];
-                arenadata.detectedcards.Add(new Tuple<string, string, string>(card0.Id, card1.Id, card2.Id));
+                for (int i = 0; i < 3; i++)
+                {
+                    cards[i] = cardlist[detectedcards[i].index];
+                }
+                valid = true;
+            }
+
+            if (valid)
+            {
+                // All cards detected
+
+                // Save detected cards
+                arenadata.detectedcards.Add(new Tuple<string, string, string>(cards[0].Id, cards[1].Id, cards[2].Id));
                 SaveArenaData();
 
                 // Update the plugin
-                plugins.CardsDetected(arenadata, card0, card1, card2);
+                plugins.CardsDetected(arenadata, cards[0], cards[1], cards[2]);
 
                 UpdateDetectedCards();
 
                 SetState(PluginState.SearchCardValues);
 
                 // Call it immediately
-                await SearchCardValues(cardindices);
+                await SearchCardValues();
             }
         }
 
-        private async Task SearchCardValues(List<int> cardindices)
+        private async Task SearchCardValues()
         {
             int lastindex = arenadata.detectedcards.Count - 1;
             if (lastindex < 0)
@@ -1752,7 +1756,7 @@ private async Task SearchCardValues(List<int> cardindices)
             loglastcardid = "";
 
             // Call it immediately
-            WaitCardPick(cardindices);
+            WaitCardPick();
         }
 
         private void SetValueText(int index, string value)
@@ -1809,7 +1813,7 @@ public string GetCardValue(string id)
             return value;
         }
 
-        private void WaitCardPick(List<int> cardindices)
+        private void WaitCardPick()
         {
             // All cards detected, wait for new pick
 
@@ -1818,7 +1822,7 @@ private void WaitCardPick(List<int> cardindices)
                 return;
 
             // Display detected cards
-            testtext.Text += "\nPicking card " + (arenadata.pickedcards.Count + 1) + "/" + MaxCardCount;
+            Debug.AppendLog("\nPicking card " + (arenadata.pickedcards.Count + 1) + "/" + MaxCardCount);
 
             List<Card> dcards = new List<Card>();
             dcards.Add(GetCard(arenadata.detectedcards[lastindex].Item1));
@@ -1831,7 +1835,7 @@ private void WaitCardPick(List<int> cardindices)
                 {
                     cardname = dcards[i].Name;
                 }
-                testtext.Text += "\nDetected " + i + ": " + cardname;
+                Debug.AppendLog("\nDetected " + i + ": " + cardname);
             }
 
             // Display picked cards
@@ -1843,7 +1847,7 @@ private void WaitCardPick(List<int> cardindices)
                 {
                     cardname = card.Name;
                 }
-                testtext.Text += "\nPicked " + i + ": " + cardname;
+                Debug.AppendLog("\nPicked " + i + ": " + cardname);
             }
 
             // Skip this if we only allow manual picking
@@ -1851,7 +1855,7 @@ private void WaitCardPick(List<int> cardindices)
             {
                 return;
             }
-            else if (uselogreader)
+            else
             {
                 // Logreader
                 if (loglastcardid != "")
@@ -1861,57 +1865,6 @@ private void WaitCardPick(List<int> cardindices)
                     loglastcardid = "";
                 }
             }
-            else
-            {
-                CardClickDetection(cardindices, dcards);
-            }
-        }
-
-        private void CardClickDetection(List<int> cardindices, List<Card> dcards)
-        {
-            // Get the click position
-            CheckMouse();
-
-            testtext.Text += "\nMouse: ";
-            for (int i = 0; i < mouseindex.Count; i++)
-            {
-                testtext.Text += mouseindex[i] + " ";
-            }
-
-            // Check if a new card was detected
-            bool newcard = false;
-            for (int i = 0; i < 3; i++)
-            {
-                int cardindex = cardindices[i];
-                if (cardindex != -1)
-                {
-                    if (dcards[i] != null)
-                    {
-                        if (dcards[i].Id != cardlist[cardindex].Id)
-                        {
-                            newcard = true;
-                            break;
-                        }
-                    }
-                }
-            }
-
-            if ((newcard || GetUndetectedCount(cardindices) == 3))
-            {
-                if (mouseindex.Count >= 1)
-                {
-                    // New card or no cards detected, the player picked a card
-                    PickCard(mouseindex[mouseindex.Count - 1]);
-
-                    // Clear the mouse data to avoid double detection of clicks
-                    mouseindex.Clear();
-                }
-                else
-                {
-                    // No click detected, missed a pick
-                    PickCard(-1);
-                }
-            }
         }
 
         // PickCard using the cardid
@@ -2059,110 +2012,6 @@ public static PluginState GetState()
             return state;
         }
 
-        private static int GetUndetectedCount(List<int> indices)
-        {
-            int undetected = 0;
-            for (int i = 0; i < indices.Count; i++)
-            {
-                if (indices[i] == -1)
-                {
-                    undetected++;
-                }
-            }
-            return undetected;
-        }
-
-        private int ConfirmDetected(List<DetectedInfo> detected, List<int> indices, int confirmations)
-        {
-            int confirmed = 0;
-            for (int i = 0; i < detected.Count; i++)
-            {
-                detected[i].Confirm(indices[i]);
-
-                if (detected[i].index != -1 && detected[i].confirmations >= confirmations)
-                {
-                    confirmed++;
-                }
-            }
-            return confirmed;
-        }
-
-        private List<int> DetectCards()
-        {
-            List<int> indices = new List<int>();
-            for (int i = 0; i < 3; i++)
-            {
-                ulong cardhash = GetScreenCardHash(i);
-                List<Tuple<int, int>> cardindices = FindHashIndex(cardhash, cardhashlist, maxcarddistance);
-
-                if (cardindices.Count == 1)
-                {
-                    indices.Add(cardindices[0].Item1);
-                }
-                else
-                {
-                    indices.Add(-1);
-                }
-
-                testtext.Text += "\nHash" + i + ": " + string.Format("0x{0:X}", cardhash);
-                foreach (Tuple<int, int> cardindex in cardindices)
-                {
-                    testtext.Text += ", " + cardlist[cardindex.Item1].Name + " (" + cardindex.Item2 + ")";
-                }
-            }
-            return indices;
-        }
-
-        private List<int> DetectHeroes()
-        {
-            List<int> indices = new List<int>();
-            for (int i = 0; i < 3; i++)
-            {
-                ulong herohash = GetScreenHeroHash(i);
-                List<Tuple<int, int>> heroindices = FindHashIndex(herohash, herohashlist, maxherodistance);
-                if (heroindices.Count == 1)
-                {
-                    indices.Add(heroindices[0].Item1);
-                }
-                else
-                {
-                    indices.Add(-1);
-                }
-                testtext.Text += "\nHero Hash" + i + ": " + string.Format("0x{0:X}", herohash);
-                foreach (Tuple<int, int> heroindex in heroindices)
-                {
-                    testtext.Text += ", " + herohashlist[heroindex.Item1].name + " (" + heroindex.Item2 + ")";
-                }
-            }
-            return indices;
-        }
-
-        private List<int> DetectBigHero()
-        {
-            List<int> indices = new List<int>();
-
-            ulong bigherohash = GetScreenHash(portraitbigcroprect, scalewidth, scaleheight);
-            List<Tuple<int, int>> bigheroindices = FindHashIndex(bigherohash, herohashlist, maxherodistance);
-            if (bigheroindices.Count == 1)
-            {
-                indices.Add(bigheroindices[0].Item1);
-            }
-            else
-            {
-                indices.Add(-1);
-            }
-
-            testtext.Text += "\nBig Hero Hash: " + string.Format("0x{0:X}", bigherohash);
-            foreach (Tuple<int, int> bigheroindex in bigheroindices)
-            {
-                testtext.Text += ", " + herohashlist[bigheroindex.Item1].name + " (" + bigheroindex.Item2 + ")";
-            }
-            testtext.Text += "\n";
-
-            return indices;
-        }
-        
-
         private void UpdateTitle()
         {
             arenawindow.Header.Text = "Picking card " + (arenadata.pickedcards.Count + 1) + "/" + MaxCardCount;
@@ -2229,333 +2078,6 @@ private void SetHeroControl(Controls.Hero herocontrol, string heroname)
             herocontrol.HeroName.Text = hero.name;
         }
 
-        private void CheckMouse()
-        {
-            // Mouse events
-            Point mousepos = GetMousePos();
-            var hsrect = Helper.GetHearthstoneRect(false);
-            mousepos.X -= hsrect.X;
-            mousepos.Y -= hsrect.Y;
-
-            short mousedown = GetAsyncKeyState(VK_LBUTTON);
-
-            if (mousepos.X < 0 || mousepos.Y < 0 || mousepos.X >= hsrect.Width || mousepos.Y >= hsrect.Height)
-            {
-                return;
-            }
-            testtext.Text += "\nMousepos: " + mousepos.X + ", " + mousepos.Y;
-
-            // Testing rectangle intersection clicking
-            /*for (int i = 0; i < 3; i++)
-            {
-                Point testcardpos = GetHSPos(hsrect, i * cardwidth + cardrect.X, cardrect.Y, scalewidth, scaleheight);
-                Point testcardsize = GetHSSize(hsrect, cardrect.Width, cardrect.Height, scalewidth, scaleheight);
-                Rectangle cardclickrect = new Rectangle(testcardpos.X, testcardpos.Y, testcardsize.X, testcardsize.Y);
-                if (cardclickrect.Contains(mousepos))
-                {
-                    testtext.Text += "\nButton " + i + " hover";
-                }
-            }*/
-
-            if (mousedown != 0)
-            {
-                double mindist = 0;
-                int closestmouseindex = 0;
-                for (int i = 0; i < 3; i++)
-                {
-                    Point cardpos = GetHSPos(hsrect, i * cardwidth + cardrect.X, cardrect.Y, scalewidth, scaleheight);
-                    Point cardsize = GetHSSize(hsrect, cardrect.Width, cardrect.Height, scalewidth, scaleheight);
-                    int centerx = cardpos.X + cardsize.X / 2;
-                    int centery = cardpos.Y + cardsize.Y / 2;
-                    double dist = Math.Sqrt((centerx - mousepos.X) * (centerx - mousepos.X) + (centery - mousepos.Y) * (centery - mousepos.Y));
-                    if (dist < mindist || i == 0)
-                    {
-                        closestmouseindex = i;
-                        mindist = dist;
-                    }
-                }
-
-                mouseindex.Add(closestmouseindex);
-                if (mouseindex.Count > 5)
-                {
-                    mouseindex.RemoveAt(0);
-                }
-            }
-        }
-
-        private ulong GetScreenCardHash(int index)
-        {
-            // Check for a valid index
-            if (index < 0 || index >= 3)
-                return 0;
-
-            var hsrect = Helper.GetHearthstoneRect(false);
-
-            // Get the position and size of the card
-            Point cardpos = GetHSPos(hsrect, index * cardwidth + cardrect.X, cardrect.Y, scalewidth, scaleheight);
-            Point cardsize = GetHSSize(hsrect, cardrect.Width, cardrect.Height, scalewidth, scaleheight);
-
-            // Copy a part of the screen
-            Bitmap capture = fullcapture.Clone(new Rectangle(cardpos.X, cardpos.Y, cardsize.X, cardsize.Y), fullcapture.PixelFormat);
-
-            ulong hash = 0;
-            if (capture != null)
-            {
-                try
-                {
-                    CropBitmapRelative(ref capture, cardrect, cardcroprect);
-
-                    System.Windows.Controls.Image imagecontrol = testimages[index];
-                    hash = GetImageHash(capture, ref imagecontrol);
-                }
-                catch (Exception e)
-                {
-                    string errormsg = "Error2: " + e.Message + "\n" + e.ToString();
-                    if (testtext != null)
-                    {
-                        testtext.Text = errormsg;
-                    }
-                    Log.Info(errormsg);
-                }
-            }
-
-            return hash;
-        }
-
-        private ulong GetScreenHeroHash(int index)
-        {
-            // Check for a valid index
-            if (index < 0 || index >= 3)
-                return 0;
-
-            var hsrect = Helper.GetHearthstoneRect(false);
-
-            // Get the position and size
-            Point pos = GetHSPos(hsrect, index * portraitwidth + portraitcroprect.X, portraitcroprect.Y, scalewidth, scaleheight);
-            Point size = GetHSSize(hsrect, portraitcroprect.Width, portraitcroprect.Height, scalewidth, scaleheight);
-
-            // Copy a part of the screen
-            Bitmap capture = fullcapture.Clone(new Rectangle(pos.X, pos.Y, size.X, size.Y), fullcapture.PixelFormat);
-
-            ulong hash = 0;
-            if (capture != null)
-            {
-                try
-                {
-                    System.Windows.Controls.Image imagecontrol = testimages[index];
-                    hash = GetImageHash(capture, ref imagecontrol);
-                }
-                catch (Exception e)
-                {
-                    string errormsg = "Error3: " + e.Message + "\n" + e.ToString();
-                    if (testtext != null)
-                    {
-                        testtext.Text = errormsg;
-                    }
-                    Log.Info(errormsg);
-                }
-            }
-
-            return hash;
-        }
-
-        private ulong GetScreenHash(Rectangle rect, int scalewidth, int scaleheight)
-        {
-            ulong hash = 0;
-            var hsrect = Helper.GetHearthstoneRect(false);
-
-            // Get the position and size of the card
-            Point pos = GetHSPos(hsrect, rect.X, rect.Y, scalewidth, scaleheight);
-            Point size = GetHSSize(hsrect, rect.Width, rect.Height, scalewidth, scaleheight);
-
-            // Copy a part of the screen
-            Bitmap capture = fullcapture.Clone(new Rectangle(pos.X, pos.Y, size.X, size.Y), fullcapture.PixelFormat);
-
-            if (capture != null)
-            {
-                try
-                {
-                    System.Windows.Controls.Image imagecontrol = testimages[0];
-                    hash = GetImageHash(capture, ref imagecontrol);
-                }
-                catch (Exception e)
-                {
-                    string errormsg = "Error4: " + e.Message + "\n" + e.ToString();
-                    if (testtext != null)
-                    {
-                        testtext.Text = errormsg;
-                    }
-                    Log.Info(errormsg);
-                }
-            }
-
-            return hash;
-        }
-
-        // Perceptual hash using the techniques from: http://www.hackerfactor.com/blog/?/archives/432-Looks-Like-It.html
-        private ulong GetImageHash(Bitmap bitmap, ref System.Windows.Controls.Image imagecontrol)
-        {
-            // Copy the image and convert to grayscale
-            Bitmap sourcebm = new Bitmap(bitmap);
-            Image<Gray, float> sourceimage = new Image<Gray, float>(sourcebm);
-
-            // Apply a convolution filter of 4x4
-            CvInvoke.Blur(sourceimage, sourceimage, new Size(4, 4), new Point(-1, -1));
-
-            // Show image for debugging
-            //Image<Bgra, Byte> convimage = Image<Bgra, Byte>.FromIplImagePtr(sourceimage);
-            //ShowBitmap(convimage.ToBitmap(), ref imagecontrol);
-
-            // Resize to 64x64 pixels
-            Image<Gray, float> resimage = new Image<Gray, float>(new Size(64, 64));
-            CvInvoke.Resize(sourceimage, resimage, new Size(64, 64));
-            //ShowBitmap(resimage.ToBitmap(), ref imagecontrol);
-
-            // DCT
-            IntPtr compleximage = CvInvoke.cvCreateImage(resimage.Size, Emgu.CV.CvEnum.IplDepth.IplDepth32F, 1);
-            CvInvoke.Dct(resimage, resimage, Emgu.CV.CvEnum.DctType.Forward);
-
-            Image<Gray, float> dctimage = Image<Gray, float>.FromIplImagePtr(resimage);
-
-            // Calculate the mean
-            double mean = 0;
-            for (int x = 0; x < 8; x++)
-            {
-                for (int y = 0; y < 8; y++)
-                {
-                    mean += dctimage[y, x].Intensity;
-                }
-            }
-            mean -= dctimage[0, 0].Intensity;
-            mean /= 63;
-
-            // Calculate the hash
-            ulong hash = 0;
-            ulong index = 1;
-            for (int x = 0; x < 8; x++)
-            {
-                for (int y = 0; y < 8; y++)
-                {
-                    Gray color = dctimage[y, x];
-                    if (color.Intensity > mean)
-                    {
-                        hash |= index;
-                        // For debugging
-                        //bitmap.SetPixel(x, y, Color.FromArgb(255, 0, 0));
-                    }
-                    else
-                    {
-                        // For debugging
-                        //bitmap.SetPixel(x, y, Color.FromArgb(0, 255, 0));
-                    }
-
-                    index <<= 1;
-                }
-            }
-
-            return hash;
-        }
-
-        private int GetHashDistance(ulong hash1, ulong hash2)
-        {
-            ulong index = 1;
-            int distance = 0;
-            for (int i = 0; i < 64; i++)
-            {
-                if ((hash1 & index) != (hash2 & index))
-                {
-                    distance++;
-                }
-
-                index <<= 1;
-            }
-
-            return distance;
-        }
-
-        private List<Tuple<int, int>> FindHashIndex(ulong hash, IEnumerable<HashData> hashlist, int maxdistance)
-        {
-            int bestindex = -1;
-            int bestdistance = 100;
-
-            List<Tuple<int, int>> indices = new List<Tuple<int, int>>();
-            int i = 0;
-            foreach (var item in hashlist)
-            {
-                // Check all item hashes
-                foreach (var itemhash in item.hashes)
-                {
-                    int distance = GetHashDistance(hash, itemhash);
-                    if (distance < maxdistance)
-                    {
-                        if (distance < bestdistance)
-                        {
-                            bestindex = i;
-                            bestdistance = distance;
-
-                            indices.Clear();
-                            indices.Add(new Tuple<int, int>(i, distance));
-                        }
-                        else if (bestindex != i && distance == bestdistance)
-                        {
-                            // Collision
-                            indices.Add(new Tuple<int, int>(i, distance));
-                        }
-                    }
-                }
-                i++;
-            }
-
-            return indices;
-        }
-
-        private List<Tuple<int, int>> FindAllHashIndex(ulong hash, IList<CardHashData> hashlist, int maxdistance)
-        {
-            List<Tuple<int, int>> indices = new List<Tuple<int, int>>();
-            for (var i = 0; i < hashlist.Count; i++)
-            {
-                // Check all item hashes
-                foreach (var itemhash in hashlist[i].hashes)
-                {
-                    int distance = GetHashDistance(hash, itemhash);
-                    if (distance < maxdistance)
-                    {
-                        indices.Add(new Tuple<int, int>(i, distance));
-                    }
-                }
-            }
-
-            return indices;
-        }
-
-        private void CropBitmapRelative(ref Bitmap bm, Rectangle fullrect, Rectangle croprect)
-        {
-            double cropx = (double)(croprect.X - fullrect.X) / fullrect.Width;
-            double cropy = (double)(croprect.Y - fullrect.Y) / fullrect.Height;
-            double cropwidth = (double)croprect.Width / fullrect.Width;
-            double cropheight = (double)croprect.Height / fullrect.Height;
-
-            bm = bm.Clone(new Rectangle((int)(cropx * bm.Width), (int)(cropy * bm.Height), (int)(cropwidth * bm.Width), (int)(cropheight * bm.Height)), bm.PixelFormat);
-        }
-
-
-        private void ShowBitmap(Bitmap bm, ref System.Windows.Controls.Image imagecontrol)
-        {
-            if (imagecontrol != null)
-            {
-
-                MemoryStream ms = new MemoryStream();
-                bm.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
-                ms.Position = 0;
-                BitmapImage bi = new BitmapImage();
-                bi.BeginInit();
-                bi.StreamSource = ms;
-                bi.EndInit();
-
-                imagecontrol.Source = bi;
-            }
-        }
-
         private void LoadData()
         {
             string assemblylocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
@@ -2626,28 +2148,6 @@ private Bitmap BitmapImage2Bitmap(BitmapImage bitmapImage)
             }
         }
 
-        // Reference resolution: 1280 x 960 (4:3)
-        private Point GetHSPos(Rectangle hsrect, int x, int y, int width, int height)
-        {
-            // Get normalized position
-            double nx = x / (double)width;
-            double ny = y / (double)height;
-
-            // Convert to actual position
-            double ratio = ((double)width / (double)height) / ((double)hsrect.Width / hsrect.Height);
-            int px = (int)((hsrect.Width * ratio * nx) + (hsrect.Width * (1 - ratio) / 2));
-            int py = (int)(ny * hsrect.Height);
-            return new Point(px, py);
-        }
-
-        // Doesn't work for too wide aspect ratios
-        private Point GetHSSize(Rectangle hsrect, int x, int y, int width, int height)
-        {
-            double scalefactor = (double)hsrect.Height / height;
-
-            return new Point((int)(scalefactor * x), (int)(scalefactor * y));
-        }
-
         // Add overlay elements for debugging
         private void AddElements()
         {
@@ -2656,7 +2156,7 @@ private void AddElements()
             {
                 for (int i = 0; i < 3; i++)
                 {
-                    ArenaHelper.Controls.ValueOverlay valuetext = new ArenaHelper.Controls.ValueOverlay();
+                    Controls.ValueOverlay valuetext = new Controls.ValueOverlay();
                     valuetext.ValueText.Text = "Value";
                     Canvas.SetLeft(valuetext, 5);
                     Canvas.SetTop(valuetext, 5);
@@ -2669,7 +2169,7 @@ private void AddElements()
             // Advice overlay
             if (adviceoverlay == null)
             {
-                adviceoverlay = new ArenaHelper.Controls.AdviceOverlay();
+                adviceoverlay = new Controls.AdviceOverlay();
                 adviceoverlay.AdviceText.Text = "";
                 Canvas.SetLeft(adviceoverlay, 5);
                 Canvas.SetTop(adviceoverlay, 5);
@@ -2678,35 +2178,39 @@ private void AddElements()
             }
 
             // Test text
-            if (testtext == null)
+            if (debugtext == null)
             {
-                testtext = new Controls.DebugTextBlock();
-                testtext.TextWrapping = System.Windows.TextWrapping.Wrap;
-                testtext.FontSize = 12;
-                testtext.Text = "Arena Helper";
-                Canvas.SetLeft(testtext, 5);
-                Canvas.SetTop(testtext, 5);
+                debugtext = new Controls.DebugTextBlock();
+                debugtext.TextWrapping = System.Windows.TextWrapping.Wrap;
+                debugtext.FontSize = 12;
+                debugtext.Text = "Arena Helper";
+                Canvas.SetLeft(debugtext, 5);
+                Canvas.SetTop(debugtext, 5);
 
-                Hearthstone_Deck_Tracker.API.Core.OverlayCanvas.Children.Add(testtext);
+                Hearthstone_Deck_Tracker.API.Core.OverlayCanvas.Children.Add(debugtext);
 
-                testtext.Visibility = System.Windows.Visibility.Hidden;
+                debugtext.Visibility = System.Windows.Visibility.Hidden;
+
+                Debug.SetTextControl(debugtext);
             }
 
             // Test images
-            if (testimages.Count == 0)
+            if (debugimages.Count == 0)
             {
                 for (int i = 0; i < 4; i++)
                 {
-                    System.Windows.Controls.Image testimage = new System.Windows.Controls.Image();
+                    System.Windows.Controls.Image debugimage = new System.Windows.Controls.Image();
 
-                    Canvas.SetLeft(testimage, 5 + i * 210);
-                    Canvas.SetTop(testimage, 550);
+                    Canvas.SetLeft(debugimage, 5 + i * 210);
+                    Canvas.SetTop(debugimage, 550);
 
-                    Hearthstone_Deck_Tracker.API.Core.OverlayCanvas.Children.Add(testimage);
+                    Hearthstone_Deck_Tracker.API.Core.OverlayCanvas.Children.Add(debugimage);
 
-                    testimage.Visibility = System.Windows.Visibility.Hidden;
-                    testimages.Add(testimage);
+                    debugimage.Visibility = System.Windows.Visibility.Hidden;
+                    debugimages.Add(debugimage);
                 }
+
+                Debug.SetImageControls(debugimages);
             }
         }
 
@@ -2726,17 +2230,19 @@ private void RemoveElements()
                 adviceoverlay = null;
             }
 
-            if (testtext != null)
+            if (debugtext != null)
             {
-                Hearthstone_Deck_Tracker.API.Core.OverlayCanvas.Children.Remove(testtext);
-                testtext = null;
+                Hearthstone_Deck_Tracker.API.Core.OverlayCanvas.Children.Remove(debugtext);
+                Debug.SetTextControl(null);
+                debugtext = null;
             }
 
-            for (int i = 0; i < testimages.Count; i++)
+            for (int i = 0; i < debugimages.Count; i++)
             {
-                Hearthstone_Deck_Tracker.API.Core.OverlayCanvas.Children.Remove(testimages[i]);
+                Hearthstone_Deck_Tracker.API.Core.OverlayCanvas.Children.Remove(debugimages[i]);
             }
-            testimages.Clear();
+            Debug.SetImageControls(null);
+            debugimages.Clear();
         }
 
     }
diff --git a/Update.cs b/Update.cs
index 040a628..196b31f 100644
--- a/Update.cs
+++ b/Update.cs
@@ -128,48 +128,32 @@ public static async Task<string> DownloadString(string url)
         }
 
         // Start auto updater
-        public static async void AutoUpdate(GithubRelease release)
+        public static async Task<bool> AutoUpdate(GithubRelease release)
         {
+            bool status = true;
             try
             {
                 if (release.Assets.Count > 0)
                 {
-                    string assemblylocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
-                    string updater = Path.Combine(assemblylocation, UpdaterFileName);
-                    Process.Start(updater, string.Format("{0} {1}", Process.GetCurrentProcess().Id, release.Assets[0].Url));
-                    Hearthstone_Deck_Tracker.API.Core.MainWindow.Close();
-                    System.Windows.Application.Current.Shutdown();
+                    // Update and install
+                    status = await AutoUpdater.Update(release.Assets[0].Url);
                 }
             }
             catch(Exception e)
             {
-                // Manual update
+                status = false;
+
                 Log.Info("AutoUpdate error: " + e.Message);
-                Process.Start(releaseDownloadUrl);
             }
+
+            return status;
         }
 
         // Clean up auto updater
+        // TODO: When coming from 0.8 and skipping a version, how to add new files (they are removed if not synced)
         public static void CleanAutoUpdate()
         {
-            try
-            {
-                string assemblylocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
-                string updater = Path.Combine(assemblylocation, UpdaterFileName);
-                string updaternew = Path.Combine(assemblylocation, UpdaterFileNameNew);
-
 
-                if (File.Exists(updaternew))
-                {
-                    if (File.Exists(updater))
-                        File.Delete(updater);
-                    File.Move(updaternew, updater);
-                }
-            }
-            catch (Exception e)
-            {
-                Log.Info("Error updating Arena Helper updater");
-            }
         }
     }
 }