Exception() публичный статический Метод

public static Exception ( Exception exception, Loglevel level = Loglevel.Debug ) : void
exception System.Exception
level Loglevel
Результат void
 public static bool Check(string path)
 {
     try
     {
         Logger.Instance.Write("Checking plugin: {0}", path);
         if (File.Exists(path))
         {
             var check = Resources.Plugin.Split('\n')[0].TrimEnd();
             using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
             {
                 var reader = new StreamReader(fs);
                 for (var i = 0; i < 3; i++)
                 {
                     var line = reader.ReadLine();
                     if (line != null && line.Equals(check))
                     {
                         Logger.Instance.Write("Plugin is installed and latest version");
                         return(true);
                     }
                 }
             }
         }
         else
         {
             Logger.Instance.Write("Plugin does not exist");
             return(false);
         }
     }
     catch (Exception ex)
     {
         DebugHelper.Exception(ex);
     }
     Logger.Instance.Write("Plugin is outdated!");
     return(false);
 }
        public static void RemoveWindowFrame(IntPtr handle, bool force = false)
        {
            if (!Settings.Default.AutoPosDiabloNoFrame && !force)
            {
                return; // Remove Frame is disabled
            }
            try
            {
                // Get current style
                var style    = WinApi.GetWindowLongPtr(handle, WinApi.WindowLongFlags.GwlStyle);
                var newstyle = ((WinApi.WindowStyles)style) & ~(WinApi.WindowStyles.WsCaption |
                                                                WinApi.WindowStyles.WsThickframe |
                                                                WinApi.WindowStyles.WsMinimize |
                                                                WinApi.WindowStyles.WsMaximize
                                                                /*| WinAPI.WindowStyles.WS_SYSMENU */); // Remove Frame from style
                WinApi.SetWindowLongPtr(new HandleRef(null, handle), WinApi.WindowLongFlags.GwlStyle,
                                        new IntPtr(Convert.ToInt64(newstyle)));                         // Set new style

                // Get current extended style
                var exStyle    = WinApi.GetWindowLongPtr(handle, WinApi.WindowLongFlags.GwlExstyle);
                var newExStyle = ((WinApi.WindowStyles)exStyle) &
                                 ~(WinApi.WindowStyles.WsExDlgmodalframe |
                                   WinApi.WindowStyles.WsExClientedge |
                                   WinApi.WindowStyles.WsExStaticedge);
                // Remove Frame from extended style
                WinApi.SetWindowLongPtr(new HandleRef(null, handle), WinApi.WindowLongFlags.GwlExstyle,
                                        new IntPtr(Convert.ToInt64(newExStyle))); // set new extended style
            }
            catch (Exception ex)
            {
                DebugHelper.Write("Failed", "RemoveWindowFrame(...)");
                DebugHelper.Exception(ex);
            }
            Thread.Sleep(100); // We need to wait a bit before we can reposition the window
        }
        public static void ManualPositionWindow(IntPtr handle, int x, int y, int w, int h, BotClass bot = null)
        {
            // Set window position and size
            try
            {
                WinAPI.RECT rct;
                if (WinAPI.GetWindowRect(new HandleRef(bot, handle), out rct))
                {
                    if (w <= 0)
                    {
                        w = rct.Width;
                    }
                    if (h <= 0)
                    {
                        h = rct.Heigth;
                    }

                    DebugHelper.Write(bot, "ManualPosition window:{0}: X:{1} Y:{2} W:{3} H:{4}", handle, x, y, w, h);
                    if (!WinAPI.SetWindowPos(handle, IntPtr.Zero, x, y, w, h, WinAPI.SetWindowPosFlags.SWP_NOACTIVATE | WinAPI.SetWindowPosFlags.SWP_NOSENDCHANGING))
                    {
                        Logger.Instance.Write(bot, "ManualPosition window:{0}: Failed!", handle);
                    }
                }
                else
                {
                    Logger.Instance.Write(bot, "ManualPosition Failed to get window rectangle");
                }
            }
            catch (Exception ex)
            {
                DebugHelper.Write(bot, "Failed", "ManualPositionWindow(...)");
                DebugHelper.Exception(ex);
            }
        }
        public static void RemoveWindowFrame(IntPtr handle, bool force = false)
        {
            if (!Settings.Default.AutoPosDiabloNoFrame && !force)
            {
                return;                                                   // Remove Frame is disabled
            }
            try
            {
                // Get current style
                var style    = WinAPI.GetWindowLongPtr(handle, WinAPI.WindowLongFlags.GWL_STYLE);
                var newstyle = ((WinAPI.WindowStyles)style) & ~(WinAPI.WindowStyles.WS_CAPTION |
                                                                WinAPI.WindowStyles.WS_THICKFRAME | WinAPI.WindowStyles.WS_MINIMIZE |
                                                                WinAPI.WindowStyles.WS_MAXIMIZE /*| WinAPI.WindowStyles.WS_SYSMENU */);        // Remove Frame from style
                WinAPI.SetWindowLongPtr(new HandleRef(null, handle), WinAPI.WindowLongFlags.GWL_STYLE, new IntPtr(Convert.ToInt64(newstyle))); // Set new style

                // Get current extended style
                var exStyle    = WinAPI.GetWindowLongPtr(handle, WinAPI.WindowLongFlags.GWL_EXSTYLE);
                var newExStyle = ((WinAPI.WindowStyles)exStyle) & ~(WinAPI.WindowStyles.WS_EX_DLGMODALFRAME |
                                                                    WinAPI.WindowStyles.WS_EX_CLIENTEDGE | WinAPI.WindowStyles.WS_EX_STATICEDGE);  // Remove Frame from extended style
                WinAPI.SetWindowLongPtr(new HandleRef(null, handle), WinAPI.WindowLongFlags.GWL_EXSTYLE, new IntPtr(Convert.ToInt64(newExStyle))); // set new extended style
            }
            catch (Exception ex)
            {
                DebugHelper.Write("Failed", "RemoveWindowFrame(...)");
                DebugHelper.Exception(ex);
            }
            Thread.Sleep(100); // We need to wait a bit before we can reposition the window
        }
Пример #5
0
        public void KillSession(BotClass bot)
        {
            lock (_webClientLock)
            {
                var logintime = bot.Demonbuddy.LoginTime;
                _webClient.Headers["Referer"] = "http://buddyauth.com/User/Sessions";
                var data  = new NameValueCollection();
                var match = GetSessions()
                            .Where(i => logintime.Subtract(i.time).TotalSeconds <16 && logintime.Subtract(i.time).TotalSeconds> -16)
                            .OrderBy(i => logintime.Subtract(i.time).TotalSeconds).FirstOrDefault();

                if (match.id == 0)
                {
                    Logger.Instance.Write(bot, "BuddyAuth: No session found.");
                    return;
                }

                data.Set("selectedSessions[" + match.number + "].Id", Convert.ToString(match.id));
                data.Set("selectedSessions[" + match.number + "].IsChecked", "true");

                try
                {
                    int retry = 3;
                    do
                    {
                        try
                        {
                            _webClient.UploadValues("http://buddyauth.com/User/Sessions", data);
                            Logger.Instance.Write(bot, "BuddyAuth: Session with id: {0} killed! (Time difference: {1})", match.id, logintime.Subtract(match.time).TotalSeconds);
                            return;
                        }
                        catch (WebException wex)
                        {
                            var code = ((HttpWebResponse)wex.Response).StatusCode;
                            if (code != HttpStatusCode.InternalServerError &&
                                code != HttpStatusCode.BadGateway &&
                                code != HttpStatusCode.ServiceUnavailable &&
                                code != HttpStatusCode.GatewayTimeout &&
                                code != HttpStatusCode.RequestTimeout)
                            {
                                Logger.Instance.Write(bot, "Failed: {0}", wex.Message);
                                return;
                            }

                            Logger.Instance.Write(bot, "Failed: {0} (next retry in 5 seconds) [{1}]", wex.Message, 3 - retry + 1);
                            Thread.Sleep(5000);
                        }
                    } while (retry-- > 0);
                }
                catch (Exception ex)
                {
                    DebugHelper.Write(bot, "BuddyAuth session killer failed!");
                    DebugHelper.Exception(ex);
                    return;
                }
                Logger.Instance.Write(bot, "BuddyAuth: No session found.");
            }
        }
Пример #6
0
 private void Send(string msg)
 {
     try
     {
         _writer.WriteLine(msg);
     }
     catch (Exception ex)
     {
         StatFailed++;
         DebugHelper.Exception(ex);
     }
 }
Пример #7
0
        public static bool CheckValidConnection(bool silent = false)
        {
            try
            {
                var wc = new WebClient();
                wc.Headers.Add("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)");
                Stream data = wc.OpenRead("http://checkip.dyndns.org");

                string ip       = string.Empty;
                string hostname = string.Empty;
                if (data != null)
                {
                    using (var reader = new StreamReader(data))
                    {
                        string s = reader.ReadToEnd();
                        Match  m =
                            new Regex(@".*Current IP Address: ([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}).*").Match
                                (s);
                        if (m.Success)
                        {
                            ip = m.Groups[1].Value;
                            if (!silent)
                            {
                                DebugHelper.Write(string.Format("Host/IP Check: IP {0}{1}", ip,
                                                                !string.IsNullOrEmpty(hostname) ? " HostName: " + hostname : ""));
                            }
                            if (!validIp(ip, silent))
                            {
                                return(false);
                            }
                        }
                        else
                        {
                            throw new Exception("No IP found!");
                        }
                    }
                    // data.Close();
                }
            }
            catch (Exception ex)
            {
                DebugHelper.Write(string.Format("ValidConnection: {0}", ex.Message));
                DebugHelper.Exception(ex);
                return(false);
            }
            return(true);
        }
Пример #8
0
        public static void UpdateScreens()
        {
            var tmpList = new List <ScreensClass>();
            var d       = new WinAPI.DisplayDevice();

            d.cb = Marshal.SizeOf(d);
            try
            {
                Logger.Instance.WriteGlobal("####[ Detecting Screens ]####");
                for (uint id = 0; WinAPI.EnumDisplayDevices(null, id, ref d, 0); id++)
                {
                    if (d.StateFlags.HasFlag(WinAPI.DisplayDeviceStateFlags.AttachedToDesktop))
                    {
                        ScreensClass screen = (Settings.Default.AutoPosScreens != null
                            ? Settings.Default.AutoPosScreens.FirstOrDefault(
                                                   x => x != null && x.DisplayDevice.DeviceKey == d.DeviceKey)
                            : null);
                        var s = new ScreensClass
                        {
                            Enabled       = (screen != null ? screen.Enabled : true),
                            Order         = (int)id,
                            DisplayDevice = d
                        };
                        tmpList.Add(s);
                        Logger.Instance.WriteGlobal("-{0} Screen {1}: X:{2},Y:{3},W:{4},H:{5} Enabled:{6}",
                                                    s.DisplayDevice.StateFlags.HasFlag(WinAPI.DisplayDeviceStateFlags.PrimaryDevice)
                                ? " Primary"
                                : "", id, s.Bounds.X, s.Bounds.Y, s.Bounds.Width, s.Bounds.Height, s.Enabled);

                        Logger.Instance.WriteGlobal("Name: {0}", s.Name);
                        Logger.Instance.WriteGlobal("Device: {0}", s.DisplayDevice.DeviceString);
                        Logger.Instance.WriteGlobal("WorkingArea: X:{0},Y:{1},W:{2},H:{3}", s.WorkingArea.X,
                                                    s.WorkingArea.Y, s.WorkingArea.Width, s.WorkingArea.Height);
                    }
                    d.cb = Marshal.SizeOf(d);
                }
                // Print screens to log
                Logger.Instance.WriteGlobal("######################");
                Settings.Default.AutoPosScreens = tmpList;
                Settings.Default.Save();
            }
            catch (Exception ex)
            {
                DebugHelper.Write("Failed", "UpdateScreens()");
                DebugHelper.Exception(ex);
            }
        }
Пример #9
0
            private void HandleXml(string data)
            {
                BotStats stats;
                var      xml = new XmlSerializer(typeof(BotStats));

                using (var stringReader = new StringReader(data))
                {
                    stats = xml.Deserialize(stringReader) as BotStats;
                }

                if (stats != null)
                {
                    try
                    {
                        BotClass bot =
                            BotSettings.Instance.Bots.FirstOrDefault(
                                b =>
                                (b != null && b.Demonbuddy != null && b.Demonbuddy.Proc != null) &&
                                b.Demonbuddy.Proc.Id == stats.Pid);
                        if (bot != null)
                        {
                            if (bot.AntiIdle.Stats == null)
                            {
                                bot.AntiIdle.Stats = new BotStats();
                            }

                            bot.AntiIdle.UpdateCoinage(stats.Coinage);
                            bot.AntiIdle.Stats     = stats;
                            bot.AntiIdle.LastStats = DateTime.Now;
                            Send(bot.AntiIdle.Reply());
                            return;
                        }

                        Logger.Instance.WriteGlobal("Could not find a matching bot for Demonbuddy:{0}", stats.Pid);
                        return;
                    }
                    catch (Exception ex)
                    {
                        StatFailed++;
                        Send("Internal server error: " + ex.Message);
                        DebugHelper.Exception(ex);
                        return;
                    }
                }
                Send("Roger!");
            }
Пример #10
0
 public void Worker()
 {
     while (true)
     {
         try
         {
             var serverStream = new NamedPipeServerStream("YetAnotherRelogger", PipeDirection.InOut, 254);
             serverStream.WaitForConnection();
             var handleClient = new HandleClient(serverStream);
             new Thread(handleClient.Start).Start();
         }
         catch (Exception ex)
         {
             StatFailed++;
             DebugHelper.Exception(ex);
         }
     }
 }
Пример #11
0
 private void Send(string msg)
 {
     try
     {
         Debug.WriteLine("Replying: " + msg);
         msg = msg.Trim();
         if (!msg.EndsWith("\n"))
         {
             msg += "\n";
         }
         _writer.WriteLine(msg);
         //_writer.Flush();
     }
     catch (Exception ex)
     {
         StatFailed++;
         DebugHelper.Exception(ex);
     }
 }
Пример #12
0
        private static void RepositionWindow(IntPtr handle, int x, int y, int w, int h)
        {
            // Set window position and size
            try
            {
                WinAPI.RECT rct;
                if (WinAPI.GetWindowRect(new HandleRef(null, handle), out rct))
                {
                    if (w <= 0)
                    {
                        w = rct.Width;
                    }
                    if (h <= 0)
                    {
                        h = rct.Heigth;
                    }

                    Debug.WriteLine("handle: {0} X:{1},Y:{2},W:{3},H:{4}", handle, rct.Left, rct.Top, rct.Width,
                                    rct.Heigth);
                    if (rct.Heigth == h && rct.Width == w && rct.Left == x && rct.Top == y)
                    {
                        DebugHelper.Write("No need to reposition: {0}", "RepositionWindow(...)", handle);
                        return;
                    }

                    if (
                        !WinAPI.SetWindowPos(handle, IntPtr.Zero, x, y, w, h,
                                             WinAPI.SetWindowPosFlags.SWP_NOACTIVATE | WinAPI.SetWindowPosFlags.SWP_NOSENDCHANGING))
                    {
                        Logger.Instance.WriteGlobal("AutoPosition window:{0}: Failed!", handle);
                    }
                }
                else
                {
                    Logger.Instance.WriteGlobal("AutoPosition Failed to get window rectangle ({0})", handle);
                }
            }
            catch (Exception ex)
            {
                DebugHelper.Write("Failed", "RepositionWindow(...)");
                DebugHelper.Exception(ex);
            }
        }
Пример #13
0
        public static void Install(string path)
        {
            try
            {
                Logger.Instance.Write("Installing latest plugin: {0}", path);
                if (File.Exists(path))
                {
                    File.Delete(path);
                }
                else if (!Directory.Exists(Path.GetDirectoryName(path)))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(path));
                }

                File.WriteAllText(path, Resources.Plugin);
            }
            catch (Exception ex)
            {
                DebugHelper.Exception(ex);
            }
        }
Пример #14
0
        public static bool Check(string path)
        {
            return(false);

            try
            {
                Logger.Instance.Write("Checking plugin: {0}", path);
                if (File.Exists(path))
                {
                    string check = Resources.Plugin.Split('\n')[0].TrimEnd(); // read the first line of Plugin.cs
                    using (var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                    {
                        var reader = new StreamReader(fs);
                        for (int i = 0; i < 3; i++) // check the first three lines of installed Plugin.cs
                        {
                            string line = reader.ReadLine();
                            if (line != null && line.Equals(check)) // line matches resource\Plugin first line
                            {
                                Logger.Instance.Write("Plugin is installed and latest version: {0}", check);
                                return(true);
                            }
                        }
                    }
                }
                else
                {
                    Logger.Instance.Write("Plugin does not exist");
                    return(false);
                }
            }
            catch (Exception ex)
            {
                DebugHelper.Exception(ex);
            }
            Logger.Instance.Write("Plugin is outdated!");
            return(false);
        }
Пример #15
0
        public static string GenerateKickstart(Profile profile, bool tmpkickstart = false)
        {
            try
            {
                string path = Path.Combine(Path.GetDirectoryName(profile.Location),
                                           string.Format("YAR{0}_Kickstart.xml", tmpkickstart ? "_TMP" : ""));

                if (File.Exists(path))
                {
                    Logger.Instance.Write("Delete old Kickstart profile: {0}", path);
                    File.Delete(path);
                }


                Logger.Instance.Write("Generate new Kickstart profile: {0}", path);
                string kickstartprofile = YarKickstart;
                // Replace stuff with current profile
                kickstartprofile = kickstartprofile.Replace("{profile}", profile.Name);
                kickstartprofile = kickstartprofile.Replace("{profile_path}", profile.Location);
                kickstartprofile = kickstartprofile.Replace("{delay}", Settings.Default.KickstartDelay.ToString());

                // Get current profile GameParams
                string gameparams = string.Empty;
                using (var reader = new StreamReader(profile.Location))
                {
                    string line;
                    // Read line for line and match with GameParamsRegex pattern to finde GameParams tag
                    while ((line = reader.ReadLine()) != null)
                    {
                        Match m = new Regex(GameParamsRegex).Match(line);
                        if (m.Success)
                        {
                            gameparams = m.Groups[1].Value;
                            break;
                        }
                    }
                }

                // GameParams not found
                if (gameparams == string.Empty)
                {
                    Logger.Instance.Write("Failed to get GameParams in profile: ", profile.Location);
                    Logger.Instance.Write("Using the profile without Kickstart!");
                    return(profile.Location);
                }

                // Insert current profile GameParams
                kickstartprofile = kickstartprofile.Replace("{gameparams}", gameparams);

                // Write Kickstart file to disk
                using (var writer = new StreamWriter(path))
                {
                    writer.WriteLine(kickstartprofile);
                }

                // Return path for kickstart file
                return(path);
            }
            catch (Exception ex)
            {
                Logger.Instance.Write("Failed to generate Kickstart profile: {0}", ex.Message);
                Logger.Instance.Write("Using the profile without Kickstart!");
                DebugHelper.Exception(ex);
                return(profile.Location);
            }
        }
Пример #16
0
        public static bool PingCheck(bool silent = false)
        {
            var ping = new Ping();

            try
            {
                // Ping host 1
                if (!silent)
                {
                    Logger.Instance.WriteGlobal("PingCheck: Ping -> {0}", Settings.Default.ConnectionCheckPingHost1);
                }
                var reply = ping.Send(Settings.Default.ConnectionCheckPingHost1, 3000);
                if (reply == null)
                {
                    if (!silent)
                    {
                        DebugHelper.Write("PingCheck: reply = NULL");
                    }
                }
                else if (reply.Status != IPStatus.Success)
                {
                    if (!silent)
                    {
                        DebugHelper.Write($"PingCheck: {reply.Address} -> {reply.Status}");
                    }
                }
                else
                {
                    if (!silent)
                    {
                        DebugHelper.Write($"PingCheck: {reply.Address} -> {reply.RoundtripTime}ms");
                    }
                    return(true);
                }
            }
            catch (Exception ex)
            {
                DebugHelper.Write(string.Format("PingCheck: Failed with message: " + ex.Message));
                DebugHelper.Exception(ex);
            }

            try
            {
                // Ping host 2
                if (!silent)
                {
                    DebugHelper.Write($"PingCheck: Ping -> {Settings.Default.ConnectionCheckPingHost2}");
                }
                var reply = ping.Send(Settings.Default.ConnectionCheckPingHost2, 3000);
                if (reply == null)
                {
                    if (!silent)
                    {
                        DebugHelper.Write("PingCheck: reply = NULL");
                    }
                }
                else if (reply.Status != IPStatus.Success)
                {
                    if (!silent)
                    {
                        DebugHelper.Write($"PingCheck: {reply.Address} -> {reply.Status}");
                    }
                }
                else
                {
                    if (!silent)
                    {
                        DebugHelper.Write($"PingCheck: {reply.Address} -> {reply.RoundtripTime}ms");
                    }
                    return(true);
                }
            }
            catch (Exception ex)
            {
                DebugHelper.Write(string.Format("PingCheck: Failed with message: " + ex.Message));
                DebugHelper.Exception(ex);
            }

            return(false);
        }
Пример #17
0
        private static bool ValidIp(string ip)
        {
            string hostname = null;

            try
            {
                hostname = Dns.GetHostEntry(ip).HostName;
            }
            catch (Exception ex)
            {
                DebugHelper.Exception(ex);
            }

            foreach (var line in Settings.Default.ConnectionCheckIpHostList.Split('\n'))
            {
                var test = line.Replace(" ", string.Empty).Trim();
                if (test.Length < 1)
                {
                    continue;
                }
                var allowed = test.StartsWith("@");
                if (allowed)
                {
                    test = test.Substring(1, test.Length - 1);
                }
                if (Settings.Default.ConnectionCheckIpCheck)
                {
                    // Check Ip range
                    var m =
                        new Regex(
                            @"([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})-([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})")
                        .Match(test);
                    if (m.Success)
                    {
                        var lowerip  = IPAddress.Parse(m.Groups[1].Value);
                        var higherip = IPAddress.Parse(m.Groups[2].Value);
                        var inrange  = new IpAddressRange(lowerip, higherip).IsInRange(IPAddress.Parse(ip));
                        if (inrange)
                        {
                            if (allowed)
                            {
                                DebugHelper.Write($"Valid Connection: IP {ip} in range -> {lowerip}-{higherip}");
                                return(true);
                            }
                            DebugHelper.Write($"Invalid Connection: IP {ip} in range -> {lowerip}-{higherip}");
                            return(false);
                        }
                        continue;
                    }
                    // Check single IP
                    m = new Regex(@"([0-9*]{1,3}\.[0-9*]{1,3}\.[0-9*]{1,3}\.[0-9*]{1,3})").Match(test);
                    if (m.Success)
                    {
                        test = m.Groups[1].Value;
                        if (General.WildcardMatch(test, ip))
                        {
                            if (allowed)
                            {
                                DebugHelper.Write($"Valid Connection: IP match {ip} -> {test}");
                                return(true);
                            }
                            DebugHelper.Write($"Invalid Connection: IP match {ip} -> {test}");
                            return(false);
                        }
                        continue;
                    }
                }

                if (hostname == null)
                {
                    continue;
                }
                if (General.WildcardMatch(test.ToLower(), hostname.ToLower()))
                {
                    if (allowed)
                    {
                        DebugHelper.Write($"Valid Connection: Host match {hostname} -> {test}");
                        return(true);
                    }
                    DebugHelper.Write($"Invalid Connection: Host match {hostname} -> {test}");
                    return(false);
                }
            }
            return(true);
        }
Пример #18
0
            private void HandleMsg(string msg)
            {
                // Message Example:
                // PID:CMD DATA
                // 1234:GameLeft 25-09-1985 18:27:00
                Debug.WriteLine("Recieved: " + msg);
                try
                {
                    string pid = msg.Split(':')[0];
                    string cmd = msg.Substring(pid.Length + 1).Split(' ')[0];
                    int    x;
                    msg = msg.Substring(((x = pid.Length + cmd.Length + 2) >= msg.Length ? 0 : x));

                    BotClass b =
                        BotSettings.Instance.Bots.FirstOrDefault(
                            f =>
                            (f.Demonbuddy != null && f.Demonbuddy.Proc != null) &&
                            f.Demonbuddy.Proc.Id == Convert.ToInt32(pid));
                    if (b == null)
                    {
                        Send("Error: Unknown process");
                        StatFailed++;
                        return;
                    }

                    switch (cmd)
                    {
                    case "Initialized":
                        b.AntiIdle.Stats = new BotStats
                        {
                            LastGame    = DateTime.Now.Ticks,
                            LastPulse   = DateTime.Now.Ticks,
                            PluginPulse = DateTime.Now.Ticks,
                            LastRun     = DateTime.Now.Ticks
                        };
                        b.AntiIdle.LastStats     = DateTime.Now;
                        b.AntiIdle.State         = IdleState.CheckIdle;
                        b.AntiIdle.IsInitialized = true;
                        b.AntiIdle.InitAttempts  = 0;
                        Send("Roger!");
                        break;

                    case "GameLeft":
                        b.ProfileSchedule.Count++;
                        if (b.ProfileSchedule.Current.Runs > 0)
                        {
                            Logger.Instance.Write(b, "Runs completed ({0}/{1})", b.ProfileSchedule.Count,
                                                  b.ProfileSchedule.MaxRuns);
                        }
                        else
                        {
                            Logger.Instance.Write(b, "Runs completed {0}", b.ProfileSchedule.Count);
                        }

                        if (b.ProfileSchedule.IsDone)
                        {
                            string newprofile = b.ProfileSchedule.GetProfile;
                            Logger.Instance.Write(b, "Next profile: {0}", newprofile);
                            Send("LoadProfile " + newprofile);
                        }
                        else
                        {
                            Send("Roger!");
                        }
                        break;

                    case "UserStop":
                        b.Status         = string.Format("User Stop: {0:d-m H:M:s}", DateTime.Now);
                        b.AntiIdle.State = IdleState.UserStop;
                        Logger.Instance.Write(b, "Demonbuddy stopped by user");
                        Send("Roger!");
                        break;

                    case "StartDelay":
                        var delay = new DateTime(long.Parse(msg));
                        b.AntiIdle.StartDelay = delay.AddSeconds(60);
                        b.AntiIdle.State      = IdleState.StartDelay;
                        Send("Roger!");
                        break;

                    // Giles Compatibility
                    case "ThirdpartyStop":
                        b.Status         = string.Format("Thirdparty Stop: {0:d-m H:M:s}", DateTime.Now);
                        b.AntiIdle.State = IdleState.UserStop;
                        Logger.Instance.Write(b, "Demonbuddy stopped by Thirdparty");
                        Send("Roger!");
                        break;

                    case "TrinityPause":
                        b.AntiIdle.State = IdleState.UserPause;
                        Logger.Instance.Write(b, "Trinity Pause Detected");
                        Send("Roger!");
                        break;

                    case "AllCompiled":
                    {
                        Logger.Instance.Write(b, "Check Force Enable Plugins? {0}", b.Demonbuddy.ForceEnableAllPlugins);
                        Send(b.Demonbuddy.ForceEnableAllPlugins ? "ForceEnableAll" : "ForceEnableYar");
                        break;
                    }

                    case "CrashTender":
                        if (Settings.Default.UseKickstart && File.Exists(msg))
                        {
                            b.Demonbuddy.CrashTender(msg);
                        }
                        else
                        {
                            b.Demonbuddy.CrashTender();
                        }
                        Send("Roger!");
                        break;

                    case "CheckConnection":
                        ConnectionCheck.CheckValidConnection(true);
                        Send("Roger!");
                        break;

                    case "NewMonsterPowerLevel":
                        Logger.Instance.Write(b, "Sending MonsterPowerLevel: {0}",
                                              b.ProfileSchedule.Current.MonsterPowerLevel);
                        Send("MonsterPower " + (int)b.ProfileSchedule.Current.MonsterPowerLevel);
                        break;

                    case "D3Exit":
                        Send("Shutdown");
                        break;

                    // Unknown command reply
                    default:
                        Send("Unknown command!");
                        Logger.Instance.WriteGlobal("Unknown command recieved: " + msg);
                        break;
                    }
                }
                catch (Exception ex)
                {
                    StatFailed++;
                    Send("Internal server error: " + ex.Message);
                    DebugHelper.Exception(ex);
                }
            }
Пример #19
0
        public static void PositionWindows()
        {
            try
            {
                var workingScreens = Settings.Default.AutoPosScreens.Where(x => x.Enabled).ToList();
                if (workingScreens.Count == 0)
                {
                    return;
                }
                workingScreens.Sort((s1, s2) => s1.Order.CompareTo(s2.Order));

                var bots = BotSettings.Instance.Bots.Where(x => x.IsEnabled);

                var sc = 0; // Screen counter
                var dy = 0; // Diablo Y-Axis counter
                var dx = 0; // Diablo X-Axis counter

                // Calculated window height
                var addy = (Settings.Default.AutoPosDiabloCascade ? 30 : Settings.Default.AutoPosDiabloH);

                foreach (var bot in bots)
                {
                    var time   = DateTime.Now;
                    var screen = workingScreens[sc]; // set current screen

                    // Calculate demonbuddy position
                    if (!(bot.Demonbuddy.ManualPosSize && !Settings.Default.ForceAutoPos))
                    {
                        // todo
                    }

                    // Calculate diablo position
                    if (!(bot.Diablo.ManualPosSize && !Settings.Default.ForceAutoPos))
                    {
                        // Dont mess with IsBoxer
                        if (bot.Diablo.UseIsBoxer)
                        {
                            continue;
                        }

                        var y = (int)(addy * dy); // get next position on Y-Axis of the screen
                        // check if window pos+height does exceed screen working area
                        if ((y + addy) > screen.WorkingArea.Height)
                        {
                            dy = y = 0;                                      // reset counters + Y-Axis position
                            dx++;                                            // move to next X-Axis "line"
                        }
                        var x = (int)(Settings.Default.AutoPosDiabloW * dx); // get next position on X-Axis of the screen
                        // check if window pos+width does exceed screen working area
                        if ((x + Settings.Default.AutoPosDiabloW) > screen.WorkingArea.Width)
                        {
                            if (!Settings.Default.AutoPosForceWorkingArea)
                            {
                                sc++;
                                // Check if screen count is bigger than actual screens available
                                if (sc > workingScreens.Count - 1)
                                {
                                    sc = 0; // reset to first screen
                                }
                            }
                            dx = x = 0; // reset counters + X-Axis position
                            dy = y = 0; // reset counters + Y-Axis position
                        }

                        if (bot.Diablo.MainWindowHandle != IntPtr.Zero)
                        {
                            RemoveWindowFrame(bot.Diablo.MainWindowHandle);
                            RepositionWindow(bot.Diablo.MainWindowHandle, x + screen.WorkingArea.X,
                                             y + screen.WorkingArea.Y, (int)Settings.Default.AutoPosDiabloW,
                                             (int)Settings.Default.AutoPosDiabloH);
                        }
                        dy++; // move to next Y-Axis "line"
                    }

                    // calculate sleeptime
                    var sleep = (int)(Program.Sleeptime - DateTime.Now.Subtract(time).TotalMilliseconds);
                    if (sleep > 0)
                    {
                        Thread.Sleep(sleep);
                    }
                }
            }
            catch (Exception ex)
            {
                DebugHelper.Write("Failed", "PositionWindows()");
                DebugHelper.Exception(ex);
            }
        }
Пример #20
0
        // Dont link this list

        public static void Create(BotClass bot)
        {
            var imp = new Impersonator();

            try
            {
                if (bot.UseWindowsUser)
                {
                    imp.Impersonate(bot.WindowsUserName, "localhost", bot.WindowsUserPassword);
                }

                bot.Status = "Create Diablo Clone";
                string basepath  = Path.GetDirectoryName(bot.Diablo.Location);
                string clonepath = Path.Combine(bot.DiabloCloneLocation, "Diablo III");

                // if diablo base path does not exist stop here!
                if (basepath != null && !Directory.Exists(basepath))
                {
                    bot.Stop();
                    throw new Exception("Diablo base directory does not exist!");
                }

                // Check if given language is installed on basepath
                string testpath = Path.Combine(basepath, @"Data_D3\PC\MPQs", General.GetLocale(bot.Diablo.Language));
                if (!Directory.Exists(testpath))
                {
                    bot.Stop();
                    throw new Exception(string.Format("ERROR: {0} language is not installed (path: {1})",
                                                      bot.Diablo.Language, testpath));
                }


                // if diablo clone does not exist create it
                if (!Directory.Exists(Path.Combine(clonepath, @"Data_D3\PC\MPQs\Cache")))
                {
                    Logger.Instance.Write(bot, "Creating new Diablo Clone");
                    Directory.CreateDirectory(Path.Combine(clonepath, @"Data_D3\PC\MPQs\Cache"));
                }

                // Create Search caches
                var baseFileCache  = new FileListCache(basepath);
                var cloneFileCache = new FileListCache(clonepath);

                // Check if all links are made for our clone
                foreach (FileListCache.MyFile p in baseFileCache.FileList)
                {
                    try
                    {
                        if (p.directory && !Directory.Exists(Path.Combine(clonepath.ToLower(), p.Path.ToLower())))
                        {
                            if (!_noLinks.Any(n => General.WildcardMatch(n.Source, p.Path)))
                            {
                                Logger.Instance.Write(bot, "NewLink: {0} -> {1}", Path.Combine(clonepath, p.Path),
                                                      Path.Combine(basepath, p.Path));
                                //if (!CreateSymbolicLink( Path.Combine(clonepath,p.Path),  Path.Combine(basepath,p.Path), 1))
                                //  throw new Exception("Failed to create link!");
                                Directory.CreateDirectory(Path.Combine(clonepath, p.Path));
                            }
                            continue;
                        }
                        if (!p.directory && !File.Exists(Path.Combine(clonepath.ToLower(), p.Path.ToLower())))
                        {
                            if (!_noLinks.Any(n => General.WildcardMatch(n.Source, p.Path)))
                            {
                                Logger.Instance.Write(bot, "NewLink: {0} -> {1}", Path.Combine(clonepath, p.Path),
                                                      Path.Combine(basepath, p.Path));
                                if (Path.GetExtension(Path.Combine(clonepath, p.Path)).ToLower().Equals(".exe"))
                                {
                                    if (
                                        !CreateHardLink(Path.Combine(clonepath, p.Path), Path.Combine(basepath, p.Path),
                                                        IntPtr.Zero))
                                    {
                                        throw new Exception("Failed to create link!");
                                    }
                                }
                                else
                                {
                                    if (
                                        !CreateSymbolicLink(Path.Combine(clonepath, p.Path),
                                                            Path.Combine(basepath, p.Path), 0))
                                    {
                                        throw new Exception("Failed to create link!");
                                    }
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex);
                    }
                }

                // Remove links that have no target

                /*
                 * foreach (var p in cloneFileCache.FileList)
                 * {
                 *  try
                 *  {
                 *      if (p.directory && !Directory.Exists(Path.Combine(basepath, p.Path)))
                 *      {
                 *          if (!_noLinks.Any(n => General.WildcardMatch(n.Source.ToLower(), p.Path.ToLower())))
                 *              Console.WriteLine("Delete: {0}", p.Path);
                 *          continue;
                 *      }
                 *
                 *      if (!p.directory && !File.Exists(Path.Combine(basepath.ToLower(), p.Path.ToLower())))
                 *      {
                 *          if (!_noLinks.Any(n => General.WildcardMatch(n.Source, p.Path)))
                 *              Console.WriteLine("Delete: {0}", p.Path);
                 *      }
                 *  }
                 *  catch (Exception ex)
                 *  {
                 *      Logger.Instance.Write(bot, ex.ToString());
                 *  }
                 * }
                 */
            }
            catch (Exception ex)
            {
                bot.Stop();
                DebugHelper.Write(bot, "Failed to create clone!");
                DebugHelper.Exception(ex);
            }
            imp.Dispose();
        }