/// <summary>
/// Add a Global Hotkey
/// </summary>
/// <param name="hotkey">Hotkey</param>
/// <returns>True on success</returns>
public bool Add(Hotkey hotkey)
{
var id = 0;
// Add hotkey to settings
try
{
Settings.Default.HotKeys.Add(hotkey);
Logger.Instance.WriteGlobal("Register hotkey: {0} - {1}+{2}", hotkey.Name,
hotkey.Modifier.ToString().Replace(", ", "+"), hotkey.Key);
id = _keyboardHook.RegisterHotKey(hotkey.Modifier, hotkey.Key);
hotkey.HookId = id;
foreach (var action in hotkey.Actions)
{
Debug.WriteLine("Initialize Hotkey: {0} {1}", action.Name, action.Version);
ActionContainer.GetAction(action.Name, action.Version).OnInitialize(hotkey);
}
}
catch (Exception ex)
{
Logger.Instance.WriteGlobal("Failed to register hotkey with message: " + ex.Message);
DebugHelper.Exception(ex);
}
return(id >= 1);
}
/// <summary>
/// Creates a new user account
/// </summary>
/// <param name="name">User login name</param>
/// <param name="password">User password</param>
/// <param name="fullName">User full name</param>
/// <param name="isAdmin">flag as admin</param>
/// <returns>returns true when user is successfully created</returns>
public static bool Create(string name, string password, string fullName = "", bool isAdmin = false)
{
try
{
var dirEntry = new DirectoryEntry("WinNT://localhost");
var entries = dirEntry.Children;
var newUser = entries.Add(name, "user");
newUser.Properties["FullName"].Add(fullName);
newUser.Invoke("SetPassword", password);
newUser.CommitChanges();
// Remove the if condition along with the else to create user account in "user" group.
DirectoryEntry grp;
grp = dirEntry.Children.Find(UserGroup, "group");
grp.Invoke("Add", new object[] { newUser.Path });
if (isAdmin)
{
grp = dirEntry.Children.Find(AdminGroup, "group");
grp.Invoke("Add", new object[] { newUser.Path });
}
}
catch (Exception ex)
{
Logger.Instance.WriteGlobal("Failed to add new user: {0}", name);
DebugHelper.Exception(ex);
return(false);
}
return((isAdmin && ExistsAsAdmin(name)) || (Exists(name)));
}
public void CrashCheck()
{
if (Proc.HasExited)
{
return;
}
if (Proc.Responding)
{
_lastRepsonse = DateTime.Now;
}
if (DateTime.Now.Subtract(_lastRepsonse).TotalSeconds > 90)
{
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Is unresponsive for more than 30 seconds", Proc.Id);
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Killing process", Proc.Id);
try
{
if (Proc != null && !Proc.HasExited)
{
Proc.CloseMainWindow();
}
//Proc.Kill();
}
catch (Exception ex)
{
Logger.Instance.Write(Parent, "Failed to kill process", ex.Message);
DebugHelper.Exception(ex);
}
}
}
private void button1_Click(object sender, EventArgs e)
{ // UP
if (dataGridView1.SelectedCells.Count <= 0 && dataGridView1.SelectedCells[0].RowIndex <= 0)
{
return;
}
try
{
var index = dataGridView1.SelectedCells[0].RowIndex;
var test = Settings.Default.AutoPosScreens.FirstOrDefault(x => x.Name == (string)dataGridView1.Rows[index].Cells["Name"].Value && x.Order > 0);
if (test != null)
{
test.Order--;
index--;
test = Settings.Default.AutoPosScreens.FirstOrDefault(x => index >= 0 && x.Name == (string)dataGridView1.Rows[index].Cells["Name"].Value && x.Order >= 0);
if (test != null)
{
test.Order++;
}
}
// Sort and update list
Settings.Default.AutoPosScreens.Sort((s1, s2) => s1.Order.CompareTo(s2.Order));
updateGridView();
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
private void updateMainformLabel(System.Windows.Forms.Label label, string value)
{
if (Program.Mainform == null || label == null)
{
return;
}
try
{
Program.Mainform.Invoke(new Action(() =>
{
try
{
label.Text = value;
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}));
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
public static bool WindowsAutoStartDel()
{
try
{
RegistryKey key = Registry.CurrentUser.CreateSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run");
if (key == null)
{
Logger.Instance.WriteGlobal(
"Failed to get registry key \"Software\\Microsoft\\Windows\\CurrentVersion\\Run\"");
return(false);
}
if (key.GetValue("YetAnotherRelogger") != null)
{
key.DeleteValue("YetAnotherRelogger");
}
key.Close();
return(true);
}
catch (Exception ex)
{
Logger.Instance.WriteGlobal("Failed to delete registry key: {0}", ex.Message);
DebugHelper.Exception(ex);
return(false);
}
}
public void CrashCheck()
{
if (Proc.HasExited)
{
return;
}
if (Proc.Responding)
{
_lastRepsonse = DateTime.Now;
Parent.Status = "Monitoring";
}
else
{
Parent.Status = string.Format("Diablo is unresponsive ({0} secs)", DateTime.Now.Subtract(_lastRepsonse).TotalSeconds);
}
if (DateTime.Now.Subtract(_lastRepsonse).TotalSeconds > 120)
{
Logger.Instance.Write("Diablo:{0}: Is unresponsive for more than 120 seconds", Proc.Id);
Logger.Instance.Write("Diablo:{0}: Killing process", Proc.Id);
try
{
if (Proc != null && !Proc.HasExited)
{
Proc.Kill();
}
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
}
protected virtual void OnPropertyChanged(string propertyName)
{
try
{
if (Program.Mainform == null)
{
return;
}
Program.Mainform.Invoke(new Action(() =>
{
try
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(propertyName));
}
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}));
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
private void ApocD3Starter()
{
Parent.Status = "D3Starter: Starting Diablo"; // Update Status
var d3StarterSuccess = false;
try
{
var starter = new Process
{
StartInfo =
{
FileName = Settings.Default.D3StarterPath,
WorkingDirectory = Path.GetDirectoryName(Settings.Default.D3StarterPath),
Arguments = string.Format("\"{0}\" 1", Location2),
UseShellExecute = false,
RedirectStandardOutput = true,
CreateNoWindow = true,
WindowStyle = ProcessWindowStyle.Hidden
}
};
starter.StartInfo = UserAccount.ImpersonateStartInfo(starter.StartInfo, Parent);
starter.Start();
Match m;
while (!starter.HasExited)
{
var l = starter.StandardOutput.ReadLine();
if (l == null)
{
continue;
}
Logger.Instance.Write("D3Starter: " + l);
if ((m = Regex.Match(l, @"Process ID (\d+) started.")).Success)
{
Proc = Process.GetProcessById(Convert.ToInt32(m.Groups[1].Value));
}
if (Regex.Match(l, @"\d game instances started! All done!").Success)
{
d3StarterSuccess = true;
break;
}
}
}
catch (Exception ex)
{
Logger.Instance.Write("D3Starter Error: {0}", ex.Message);
DebugHelper.Exception(ex);
}
if (!d3StarterSuccess)
{
Logger.Instance.Write("D3Starter failed!");
Parent.Stop();
Parent.Status = "D3Starter Failed!";
}
}
private void CreateChartStats(BotClass bot, Chart graph, ChartValueType valueType = ChartValueType.Auto)
{
if (Program.Mainform != null && graph != null)
{
try
{
Program.Mainform.Invoke(new Action(() =>
{
try
{
if (bot.IsRunning)
{
Series serie = graph.Series.FirstOrDefault(x => x.Name == bot.Name);
if (serie == null)
{
// Add Series
graph.Series.Add(bot.Name);
graph.Series[bot.Name].ChartType = SeriesChartType.FastLine;
graph.Series[bot.Name].Points.Add(0);
graph.Series[bot.Name].YAxisType = AxisType.Primary;
graph.Series[bot.Name].YValueType = valueType;
graph.Series[bot.Name].IsXValueIndexed = false;
graph.Series[bot.Name].Color = Color.Black;
foreach (
Color color in
ChartColors.Where(color => graph.Series.All(x => x.Color != color))
)
{
graph.Series[bot.Name].Color = color;
}
graph.Series[bot.Name].Name = bot.Name;
}
}
else
{
Series serie = graph.Series.FirstOrDefault(x => x.Name == bot.Name);
if (serie != null)
{
graph.Series.Remove(serie);
}
}
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}));
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
}
public static void Stop()
{
try
{
mutex.ReleaseMutex();
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
private static void UpdateMainformGraph(Chart graph, string serie, double value, int limit = 120, string legend = null,
bool autoscale = false)
{
if (Program.Mainform == null || graph == null)
{
return;
}
try
{
Program.Mainform.Invoke(new Action(() =>
{
try
{
if (legend != null)
{
graph.Series[serie].LegendText = legend;
}
while (graph.Series[serie].Points.Count < limit)
{
graph.Series[serie].Points.Add(0);
}
if (value > 0)
{
graph.Series[serie].Points.Add(value);
}
else
{
graph.Series[serie].Points.Add(0);
}
while (graph.Series[serie].Points.Count > limit)
{
graph.Series[serie].Points.RemoveAt(0);
}
if (autoscale)
{
graph.ChartAreas[0].AxisY.Minimum = double.NaN;
graph.ChartAreas[0].AxisY.Maximum = double.NaN;
graph.ChartAreas[0].RecalculateAxesScale();
}
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}));
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
private void prepareMainGraphConnections()
{
if (Program.Mainform == null || Program.Mainform.CommConnections == null)
{
return;
}
try
{
Program.Mainform.Invoke(new Action(() =>
{
try
{
// Clear mainform stats
var graph = Program.Mainform.CommConnections;
graph.Series.Clear();
graph.Palette = ChartColorPalette.Pastel;
graph.Titles.Clear();
graph.Titles.Add("Communicator Open Connections");
// Add Series
graph.Series.Add("Connections");
graph.Series["Connections"].ChartType = SeriesChartType.FastLine;
graph.Series["Connections"].Points.Add(0);
graph.Series["Connections"].YAxisType = AxisType.Primary;
graph.Series["Connections"].YValueType = ChartValueType.Int32;
graph.Series["Connections"].IsXValueIndexed = false;
graph.Series["Connections"].Color = Color.DarkSlateBlue;
graph.Series.Add("Failed");
graph.Series["Failed"].ChartType = SeriesChartType.FastLine;
graph.Series["Failed"].Points.Add(0);
graph.Series["Failed"].YAxisType = AxisType.Secondary;
graph.Series["Failed"].YValueType = ChartValueType.Int32;
graph.Series["Failed"].IsXValueIndexed = false;
graph.Series["Failed"].Color = Color.Red;
graph.ResetAutoValues();
graph.ChartAreas[0].AxisY.Maximum = 255; //Max Y
graph.ChartAreas[0].AxisY.Minimum = 0;
graph.ChartAreas[0].AxisX.Enabled = AxisEnabled.False;
graph.ChartAreas[0].AxisY.IntervalAutoMode = IntervalAutoMode.VariableCount;
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}));
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
public static bool ChangeRegion(string region)
{
try
{
var key = Registry.CurrentUser.CreateSubKey(@"Software\Blizzard Entertainment\Battle.net\D3\");
if (key == null)
{
Logger.Instance.Write("Failed to get registry key for changing region!");
return(false);
}
string regionUrl;
switch (region)
{
case "Beta":
regionUrl = "beta.actual.battle.net";
break;
case "Europe":
regionUrl = "eu.actual.battle.net";
break;
case "America":
regionUrl = "us.actual.battle.net";
break;
case "Asia":
regionUrl = "kr.actual.battle.net";
break;
case "China":
regionUrl = "cn.actual.battle.net";
break;
default:
Logger.Instance.Write("Unknown region ({0}) using Europe as our default region", region);
regionUrl = "eu.actual.battle.net";
break;
}
Logger.Instance.Write("Region set: {0} : {1}", region, regionUrl);
key.SetValue("RegionUrl", regionUrl);
key.Close();
return(true);
}
catch (Exception ex)
{
Logger.Instance.Write("Changing Region Failed!");
DebugHelper.Exception(ex);
return(false);
}
}
public void CrashCheck()
{
if (Proc.HasExited)
{
return;
}
if (Proc.Responding)
{
_lastRepsonse = DateTime.UtcNow;
}
if (DateTime.UtcNow.Subtract(Proc.StartTime).TotalMilliseconds < (90 * 1000))
{
return;
}
if (Settings.Default.AllowKillDemonbuddy && DateTime.UtcNow.Subtract(_lastRepsonse).TotalSeconds > 90)
{
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Is unresponsive for more than 120 seconds", Proc.Id);
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Killing process", Proc.Id);
try
{
Proc.Kill();
}
catch (Exception ex)
{
Logger.Instance.Write(Parent, "Failed to kill process", ex.Message);
DebugHelper.Exception(ex);
}
}
else if (Settings.Default.AllowKillDemonbuddy && DateTime.UtcNow.Subtract(_lastRepsonse).TotalSeconds > 90)
{
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Is unresponsive for more than 90 seconds", Proc.Id);
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Closing process", Proc.Id);
try
{
if (Proc != null && !Proc.HasExited)
{
Proc.CloseMainWindow();
}
//Proc.Kill();
}
catch (Exception ex)
{
Logger.Instance.Write(Parent, "Failed to kill process", ex.Message);
DebugHelper.Exception(ex);
}
}
}
public static Int64 GetTotalMemory()
{
try
{
var pi = new PerformanceInformation();
if (GetPerformanceInfo(out pi, Marshal.SizeOf(pi)))
{
return(Convert.ToInt64((pi.PhysicalTotal.ToInt64() * pi.PageSize.ToInt64())));
}
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
return(-1);
}
private void prepareMainGraphGold()
{
if (Program.Mainform == null || Program.Mainform.GoldStats == null)
{
return;
}
try
{
Program.Mainform.Invoke(new Action(() =>
{
try
{
// Clear mainform stats
var graph = Program.Mainform.GoldStats;
graph.Series.Clear();
graph.Palette = ChartColorPalette.Pastel;
graph.Titles.Clear();
graph.Titles.Add("Gold Statistics");
// Add Series
graph.Series.Add("Gph");
graph.Series["Gph"].ChartType = SeriesChartType.FastLine;
graph.Series["Gph"].Points.Add(0);
graph.Series["Gph"].YAxisType = AxisType.Primary;
graph.Series["Gph"].YValueType = ChartValueType.Auto;
graph.Series["Gph"].IsXValueIndexed = false;
graph.Series["Gph"].Color = Color.DarkSlateBlue;
graph.ResetAutoValues();
graph.ChartAreas[0].AxisY.Minimum = 0;
graph.ChartAreas[0].AxisX.Enabled = AxisEnabled.False;
graph.ChartAreas[0].AxisY.IntervalAutoMode = IntervalAutoMode.VariableCount;
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}));
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
public static void AgentKiller()
{
foreach (var p in Process.GetProcessesByName("Agent"))
{
try
{
if (!p.MainModule.FileVersionInfo.ProductName.Equals("Battle.net Update Agent"))
{
continue;
}
Logger.Instance.Write("Killing Agent.exe:{0}", p.Id);
p.Kill();
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
}
void GenerateSchedule()
{
int x = 0; // start at X-Axis
int y = 14; // start at Y-Axis
int n = 0; // box number
bool bHeader = false;
try
{
for (int d = 1; d <= 7; d++)
{
for (int h = 0; h <= 23; h++)
{
if (!bHeader)
{
var l = new Label();
l.Location = new Point(x + 1, 0);
l.Margin = new Padding(0);
l.Name = "lbl" + n;
l.Text = n.ToString("D2"); // add leading zero when needed (2 digits)
l.Size = new Size(20, 13);
l.TextAlign = ContentAlignment.MiddleCenter;
this.Invoke(new Action(() => this.BoxPanel.Controls.Add(l)));
}
ScheduleBox[n] = new ClickBox("box" + n, x, y);
this.Invoke(new Action(() => this.BoxPanel.Controls.Add(ScheduleBox[n].box)));
n++;
x += 20; // X-Axis
}
bHeader = true;
y += 20; // Y-Axis
x = 0; // X-Axis
}
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
isDone = true;
}
public static bool WindowsAutoStartAdd()
{
try
{
var key = Registry.CurrentUser.CreateSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run");
if (key == null)
{
Logger.Instance.WriteGlobal("Failed to get registry key \"Software\\Microsoft\\Windows\\CurrentVersion\\Run\"");
return(false);
}
key.SetValue("YetAnotherRelogger", string.Format("\"{0}\" -winstart", Application.ExecutablePath));
key.Close();
return(true);
}
catch (Exception ex)
{
Logger.Instance.WriteGlobal("Failed to add/change registry key: {0}", ex.Message);
DebugHelper.Exception(ex);
return(false);
}
}
public static bool ChangeLocale(string Language)
{
try
{
var locale = Tools.General.GetLocale(Language);
var key = Registry.CurrentUser.CreateSubKey(@"Software\Blizzard Entertainment\D3");
if (key == null)
{
Logger.Instance.Write("Failed to get registry key for changing locale!");
return(false);
}
Logger.Instance.Write("Language set: {0} : {1}", Language, locale);
key.SetValue("Locale", locale);
key.Close();
return(true);
}
catch (Exception ex)
{
Logger.Instance.Write("Failed to change locale!");
DebugHelper.Exception(ex);
return(false);
}
}
private void ReloggerWorker()
{
// Check if we are launched by windows RUN
if (CommandLineArgs.WindowsAutoStart && !_autoStartDone)
{
_autoStartDone = true;
Logger.Instance.WriteGlobal("Windows auto start delaying with {0} seconds", Settings.Default.StartDelay);
Thread.Sleep((int)Settings.Default.StartDelay * 1000);
foreach (BotClass bot in BotSettings.Instance.Bots.Where(c => c.IsEnabled))
{
bot.AntiIdle.Reset(freshstart: true); // Reset AntiIdle
bot.IsStarted = true;
bot.Status = "Auto Start...";
}
}
// Check if we are launched with the autostart
if (CommandLineArgs.AutoStart && !_autoStartDone)
{
_autoStartDone = true;
foreach (BotClass bot in BotSettings.Instance.Bots.Where(c => c.IsEnabled))
{
bot.AntiIdle.Reset(freshstart: true); // Reset AntiIdle
bot.IsStarted = true;
bot.Status = "Auto Start...";
}
}
DebugHelper.Write("Relogger Thread Starting!");
while (true)
{
try
{
if (_isStopped)
{
return;
}
// Paused
if (Program.Pause)
{
Thread.Sleep(1000);
continue;
}
List <Process> blizzardErrorProcs =
(from p in Process.GetProcessesByName("BlizzardError.exe")
select p).ToList();
if (blizzardErrorProcs.Any())
{
try
{
foreach (var p in blizzardErrorProcs)
{
Logger.Instance.Write("Killing BlizzardError.exe with PID {0}", p.Id);
p.Kill();
}
}
catch (Exception ex)
{
Logger.Instance.Write("Exception killing BlizzardError.exe: " + ex);
}
}
if (DateTime.UtcNow.Subtract(_lastSaveSettings).TotalSeconds > 10)
{
_lastSaveSettings = DateTime.UtcNow;
Settings.Default.Save();
BotSettings.Instance.Save();
}
// Check / validate internet connection
if (!ConnectionCheck.IsConnected || !ConnectionCheck.ValidConnection)
{
Debug.WriteLine("Internet validation failed looping until success");
Thread.Sleep(1000);
continue;
}
foreach (BotClass bot in BotSettings.Instance.Bots.Where(bot => bot != null).ToList())
{
if (Program.Pause)
{
break;
}
DateTime time = DateTime.UtcNow; // set current time to calculate sleep time at end of loop
CurrentBot = bot;
//Debug.WriteLine(bot.Name + ":" + ":" + bot.IsRunning);
//Debug.WriteLine("State=" + bot.AntiIdle.State);
if (bot.IsRunning && bot.IsStarted && !bot.Week.ShouldRun(bot.IsRunning))
{
// We need to stop
Logger.Instance.Write("We are scheduled to stop");
bot.Week.NextSchedule(true);
bot.IsRunning = false;
bot.Demonbuddy.Stop();
bot.Diablo.Stop();
bot.Status = "Scheduled stop!";
}
else if (!bot.IsRunning && bot.IsStarted && bot.Week.ShouldRun(bot.IsRunning))
{
// we need to start
Logger.Instance.Write("We are scheduled to start");
bot.Week.NextSchedule(false);
bot.IsRunning = true;
bot.StartTime = DateTime.UtcNow;
StartBoth(bot);
}
else if (!bot.IsStandby && bot.IsRunning)
{
// Check if process is responding
bot.Diablo.CrashCheck();
if (bot.AntiIdle.IsInitialized)
{
bot.Demonbuddy.CrashCheck();
}
if (!bot.Diablo.IsRunning)
{
if (bot.Diablo.Proc != null)
{
Logger.Instance.Write("Diablo:{0}: Process is not running", bot.Diablo.Proc.Id);
}
//if (bot.Demonbuddy.IsRunning && bot.Demonbuddy.Proc != null)
//{
// Logger.Instance.Write("Demonbuddy:{0}: Closing db", bot.Demonbuddy.Proc.Id);
// bot.Demonbuddy.Stop();
//}
if (bot.Demonbuddy.IsRunning && bot.Demonbuddy.Proc != null)
{
Logger.Instance.Write("Demonbuddy:{0}: Waiting for Demonbuddy to self close", bot.Demonbuddy.Proc.Id);
}
else
{
StartBoth(bot);
}
}
else if (!bot.Demonbuddy.IsRunning)
{
Logger.Instance.Write("Demonbuddy: Process is not running");
bot.Demonbuddy.Start();
}
else if (Settings.Default.AntiIdleStatsDuration > 0 && bot.AntiIdle.State != IdleState.Initialize && General.DateSubtract(bot.AntiIdle.LastStats) >
(double)Settings.Default.AntiIdleStatsDuration)
{
Logger.Instance.Write("We did not recieve any stats during 300 seconds!");
bot.Restart();
}
else if (bot.AntiIdle.IsInitialized)
{
if (bot.ProfileSchedule.IsDone)
{
Logger.Instance.Write("Profile: \"{0}\" Finished!", bot.ProfileSchedule.Current.Name);
bot.AntiIdle.State = IdleState.NewProfile;
}
}
}
else
{
//Logger.Instance.Write("Bot Standby={0} Running={1} D3Running={2} DBRunning={3}", bot.IsStandby, bot.IsRunning, bot.Diablo.IsRunning, bot.Demonbuddy.IsRunning);
bot.StartTime = DateTime.UtcNow;
}
// calculate sleeptime
var sleep = (int)(Program.Sleeptime - DateTime.UtcNow.Subtract(time).TotalMilliseconds);
if (sleep > 0)
{
Thread.Sleep(sleep);
}
}
} // try
catch (InvalidOperationException)
{
// Catch error when bot is edited while in a loop
//Logger.Instance.WriteGlobal(iox.Message);
continue;
}
catch (Exception ex)
{
if (_isStopped)
{
return;
}
Logger.Instance.WriteGlobal("Relogger Crashed! with message {0}", ex.Message);
DebugHelper.Exception(ex);
Logger.Instance.WriteGlobal("Waiting 10 seconds and try again!");
Thread.Sleep(10000);
continue;
}
Thread.Sleep(1000);
} // while
} // private void reloggerWorker()
public void StatsUpdaterWorker()
{
// Wait here till mainform is up
while (Program.Mainform == null || !Program.Mainform.IsHandleCreated)
{
Thread.Sleep(100);
}
var usages = new CpuRamUsage();
var totalRam = PerformanceInfo.GetTotalMemory();
PrepareMainGraphCpu();
PrepareMainGraphMemory();
PrepareMainGraphGold();
while (true)
{
// Update Cpu/Ram Usage
usages.Update();
double diabloCpuUsage = 0;
long diabloRamUsage = 0;
double demonbuddyCpuUsage = 0;
long demonbuddyRamUsage = 0;
double goldPerHour = 0;
double totalGold = 0;
lock (BotSettings.Instance)
{
foreach (var bot in BotSettings.Instance.Bots.ToList())
{
var chartStats = bot.ChartStats;
// Update bot uptime
bot.RunningTime = bot.IsRunning
? DateTime.UtcNow.Subtract(bot.StartTime).ToString(@"hh\hmm\mss\s")
: "";
// Update bot specific Chart stats
CreateChartStats(bot, Program.Mainform.GoldStats, ChartValueType.Double);
if (bot.IsRunning)
{
#region Calculate System Usage
if (bot.Diablo.IsRunning)
{
// Calculate total Cpu/Ram usage for Diablo
try
{
var usage = usages.GetUsageById(bot.Diablo.Proc.Id);
diabloCpuUsage += usage.Cpu;
diabloRamUsage += usage.Memory;
}
catch (Exception)
{
}
}
if (bot.Demonbuddy.IsRunning)
{
// Calculate total Cpu/Ram usage for Demonbuddy
try
{
var usage = usages.GetUsageById(bot.Demonbuddy.Proc.Id);
demonbuddyCpuUsage += usage.Cpu;
demonbuddyRamUsage += usage.Memory;
}
catch (Exception)
{
}
}
#endregion
#region Gold Stats
chartStats.GoldStats.Update(bot); // Update Current bot
// Calculate total gold for all bots
goldPerHour += chartStats.GoldStats.GoldPerHour;
totalGold += chartStats.GoldStats.LastCoinage;
var serie = Program.Mainform.GoldStats.Series.FirstOrDefault(x => x.Name == bot.Name);
if (serie != null)
{
UpdateMainformGraph(Program.Mainform.GoldStats, serie.Name,
Math.Round(chartStats.GoldStats.GoldPerHour), (int)Settings.Default.StatsGphHistory,
autoscale: true);
}
#endregion
}
}
}
try
{
// add to Cpu graph
var graph = Program.Mainform.CpuUsage;
var allusage = diabloCpuUsage + demonbuddyCpuUsage;
UpdateMainformGraph(graph, "All Usage", allusage,
legend: $"All usage: {allusage,11:000.0}%",
limit: (int)Settings.Default.StatsCPUHistory);
UpdateMainformGraph(graph, "Diablo", diabloCpuUsage,
legend: $"Diablo: {diabloCpuUsage,16:000.0}%",
limit: (int)Settings.Default.StatsCPUHistory);
UpdateMainformGraph(graph, "Demonbuddy", demonbuddyCpuUsage,
legend: $"Demonbuddy: {demonbuddyCpuUsage,4:000.0}%",
limit: (int)Settings.Default.StatsCPUHistory);
UpdateMainformGraph(graph, "Total System", Math.Round(usages.TotalCpuUsage, 2),
legend: $"Total System: {usages.TotalCpuUsage,2:000.0}%",
limit: (int)Settings.Default.StatsCPUHistory);
// add to Memory graph
graph = Program.Mainform.MemoryUsage;
allusage = (double)(diabloRamUsage + demonbuddyRamUsage) / totalRam * 100;
var diablousage = (double)diabloRamUsage / totalRam * 100;
var demonbuddyusage = (double)demonbuddyRamUsage / totalRam * 100;
UpdateMainformGraph(graph, "All Usage", allusage,
legend:
$"All usage: {((double)(diabloRamUsage + demonbuddyRamUsage) / totalRam * 100),11:000.0}%",
limit: (int)Settings.Default.StatsMemoryHistory);
UpdateMainformGraph(graph, "Diablo", diablousage,
legend: $"Diablo: {diablousage,16:000.0}%",
limit: (int)Settings.Default.StatsMemoryHistory);
UpdateMainformGraph(graph, "Demonbuddy", demonbuddyusage,
legend: $"Demonbuddy: {demonbuddyusage,4:000.0}%",
limit: (int)Settings.Default.StatsMemoryHistory);
var mem = (double)PerformanceInfo.GetPhysicalUsedMemory() / totalRam * 100;
UpdateMainformGraph(graph, "Total System", mem,
legend: $"Total System: {mem,2:000.0}%",
limit: (int)Settings.Default.StatsMemoryHistory);
// add to Gold Graph
UpdateMainformGraph(Program.Mainform.GoldStats, "Gph", Math.Round(goldPerHour),
legend: $"Gph {Math.Round(goldPerHour)}", autoscale: true,
limit: (int)Settings.Default.StatsGphHistory);
UpdateMainformLabel(Program.Mainform.CashPerHour,
$"{(goldPerHour / 1000000 * (double)Settings.Default.StatsGoldPrice):C2}");
UpdateMainformLabel(Program.Mainform.CurrentCash,
$"{(totalGold / 1000000 * (double)Settings.Default.StatsGoldPrice):C2}");
UpdateMainformLabel(Program.Mainform.TotalGold, $"{totalGold:N0}");
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
Thread.Sleep((int)Settings.Default.StatsUpdateRate);
}
}
public void Start()
{
if (!Parent.IsStarted)
{
return;
}
if (!File.Exists(Location))
{
Logger.Instance.Write("File not found: {0}", Location);
return;
}
_isStopped = false;
// Ping check
while (Settings.Default.ConnectionCheckPing && !ConnectionCheck.PingCheck() && !_isStopped)
{
Parent.Status = "Wait on internet connection";
Logger.Instance.WriteGlobal("PingCheck: Waiting 10 seconds and trying again!");
Thread.Sleep(10000);
}
// Check valid host
while (Settings.Default.ConnectionCheckIpHost && !ConnectionCheck.CheckValidConnection() && !_isStopped)
{
Parent.Status = "Wait on host validation";
Logger.Instance.WriteGlobal("ConnectionValidation: Waiting 10 seconds and trying again!");
Thread.Sleep(10000);
}
// Check if we need to create a Diablo clone
if (Parent.UseDiabloClone)
{
DiabloClone.Create(Parent);
}
Parent.Status = "Prepare Diablo"; // Update Status
General.AgentKiller(); // Kill all Agent.exe processes
// Prepare D3 for launch
var agentDBPath = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + @"\Battle.net\Agent\agent.db";
if (File.Exists(agentDBPath))
{
Logger.Instance.Write("Deleting: {0}", agentDBPath);
try
{
File.Delete(agentDBPath);
}
catch (Exception ex)
{
Logger.Instance.Write("Failed to delete! Exception: {0}", ex.Message);
DebugHelper.Exception(ex);
}
}
// Copy D3Prefs
if (!string.IsNullOrEmpty(Parent.D3PrefsLocation))
{
D3Prefs();
}
// Registry Changes
RegistryClass.ChangeLocale(Parent.Diablo.Language); // change language
RegistryClass.ChangeRegion(Parent.Diablo.Region); // change region
if (UseIsBoxer)
{
IsBoxerStarter();
}
else if (Settings.Default.UseD3Starter)
{
ApocD3Starter();
}
else
{
try
{
var arguments = "-launch";
var pi = new ProcessStartInfo(Location2, arguments)
{
WorkingDirectory = Path.GetDirectoryName(Location2)
};
pi = UserAccount.ImpersonateStartInfo(pi, Parent);
// Set working directory to executable location
Parent.Status = "Starting Diablo"; // Update Status
Proc = Process.Start(pi);
}
catch (Exception ex)
{
Parent.Stop();
DebugHelper.Exception(ex);
return;
}
}
if (!UseIsBoxer) // Don't want to fight with isboxer
{
if (CpuCount != Environment.ProcessorCount)
{
ProcessorAffinity = AllProcessors; // set it to all ones
CpuCount = Environment.ProcessorCount;
}
Proc.ProcessorAffinity = (IntPtr)ProcessorAffinity;
}
if (_isStopped)
{
return; // Halt here when bot is stopped while we where waiting for it to become active
}
// Wait for d3 to fully load
var state = (Settings.Default.UseD3Starter || UseIsBoxer ? 0 : 2);
var handle = IntPtr.Zero;
var timedout = false;
LimitStartTime(true); // reset startup time
while ((!Proc.HasExited && state < 4))
{
if (timedout)
{
return;
}
//Debug.WriteLine("Splash: " + FindWindow.FindWindowClass("D3 Splash Window Class", Proc.Id) + " Main:" + FindWindow.FindWindowClass("D3 Main Window Class", Proc.Id));
switch (state)
{
case 0:
handle = FindWindow.FindWindowClass("D3 Splash Window Class", Proc.Id);
if (handle != IntPtr.Zero)
{
Logger.Instance.Write("Diablo:{0}: Found D3 Splash Window ({1})", Proc.Id, handle);
state++;
LimitStartTime(true); // reset startup time
}
timedout = LimitStartTime();
break;
case 1:
handle = FindWindow.FindWindowClass("D3 Splash Window Class", Proc.Id);
if (handle == IntPtr.Zero)
{
Logger.Instance.Write("Diablo:{0}: D3 Splash Window Closed ({1})", Proc.Id, handle);
state++;
LimitStartTime(true); // reset startup time
}
timedout = LimitStartTime();
break;
case 2:
handle = FindWindow.FindWindowClass("D3 Main Window Class", Proc.Id);
if (handle != IntPtr.Zero)
{
Logger.Instance.Write("Diablo:{0}: Found D3 Main Window ({1})", Proc.Id, handle);
state++;
LimitStartTime(true); // reset startup time
}
timedout = LimitStartTime();
break;
case 3:
if (CrashChecker.IsResponding(handle))
{
MainWindowHandle = handle;
state++;
LimitStartTime(true); // reset startup time
}
timedout = LimitStartTime();
break;
}
Thread.Sleep(500);
}
if (timedout)
{
return;
}
if (Program.IsRunAsAdmin)
{
Proc.PriorityClass = General.GetPriorityClass(Priority);
}
else
{
Logger.Instance.Write(Parent, "Failed to change priority (No admin rights)");
}
// Continue after launching stuff
Logger.Instance.Write("Diablo:{0}: Waiting for process to become ready", Proc.Id);
var timeout = DateTime.Now;
while (true)
{
if (General.DateSubtract(timeout) > 30)
{
Logger.Instance.Write("Diablo:{0}: Failed to start!", Proc.Id);
Parent.Restart();
return;
}
Thread.Sleep(500);
try
{
Proc.Refresh();
if (Proc.WaitForInputIdle(100) || CrashChecker.IsResponding(MainWindowHandle))
{
break;
}
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
if (!IsRunning)
{
return;
}
_lastRepsonse = DateTime.Now;
Thread.Sleep(1500);
if (NoFrame)
{
AutoPosition.RemoveWindowFrame(MainWindowHandle, true); // Force remove window frame
}
if (ManualPosSize)
{
AutoPosition.ManualPositionWindow(MainWindowHandle, X, Y, W, H, Parent);
}
else if (Settings.Default.UseAutoPos)
{
AutoPosition.PositionWindows();
}
Logger.Instance.Write("Diablo:{0}: Process is ready", Proc.Id);
// Demonbuddy start delay
if (Settings.Default.DemonbuddyStartDelay > 0)
{
Logger.Instance.Write("Demonbuddy start delay, waiting {0} seconds", Settings.Default.DemonbuddyStartDelay);
Thread.Sleep((int)Settings.Default.DemonbuddyStartDelay * 1000);
}
}
private void ForegroundCheckerWorker()
{
try
{
while (true)
{
BindingList <BotClass> bots = BotSettings.Instance.Bots;
IntPtr hwnd = WinAPI.GetForegroundWindow();
if (_lastDemonbuddy != hwnd && _lastDiablo != hwnd)
{
_lastDemonbuddy = _lastDiablo = IntPtr.Zero;
foreach (BotClass bot in bots)
{
DateTime time = DateTime.Now;
if (!bot.IsStarted || !bot.IsRunning || !bot.Diablo.IsRunning || !bot.Demonbuddy.IsRunning)
{
continue;
}
if (bot.Diablo.Proc.MainWindowHandle != hwnd)
{
continue;
}
_lastDiablo = bot.Diablo.MainWindowHandle;
_lastDemonbuddy = bot.Demonbuddy.MainWindowHandle;
Logger.Instance.WriteGlobal(
"<{0}> Diablo:{1}: has focus. Bring attached Demonbuddy to front", bot.Name,
bot.Diablo.Proc.Id);
// Bring demonbuddy to front
WinAPI.ShowWindow(_lastDemonbuddy, WinAPI.WindowShowStyle.ShowNormal);
WinAPI.SetForegroundWindow(_lastDemonbuddy);
DateTime timeout = DateTime.Now;
while (WinAPI.GetForegroundWindow() != _lastDemonbuddy)
{
if (General.DateSubtract(timeout, false) > 500)
{
WinAPI.ShowWindow(_lastDemonbuddy, WinAPI.WindowShowStyle.ForceMinimized);
Thread.Sleep(300);
WinAPI.ShowWindow(_lastDemonbuddy, WinAPI.WindowShowStyle.ShowNormal);
Thread.Sleep(300);
WinAPI.SetForegroundWindow(_lastDemonbuddy);
if (WinAPI.GetForegroundWindow() != _lastDemonbuddy)
{
Logger.Instance.WriteGlobal("<{0}> Failed to bring Demonbuddy to front",
bot.Name);
}
break;
}
Thread.Sleep(100);
}
// Switch back to diablo
WinAPI.ShowWindow(_lastDiablo, WinAPI.WindowShowStyle.ShowNormal);
WinAPI.SetForegroundWindow(_lastDiablo);
while (WinAPI.GetForegroundWindow() != _lastDiablo)
{
if (General.DateSubtract(timeout, false) > 500)
{
WinAPI.ShowWindow(_lastDiablo, WinAPI.WindowShowStyle.ForceMinimized);
Thread.Sleep(300);
WinAPI.ShowWindow(_lastDiablo, WinAPI.WindowShowStyle.ShowNormal);
Thread.Sleep(300);
WinAPI.SetForegroundWindow(_lastDiablo);
break;
}
Thread.Sleep(100);
}
// calculate sleeptime
var sleep = (int)(Program.Sleeptime - DateTime.Now.Subtract(time).TotalMilliseconds);
if (sleep > 0)
{
Thread.Sleep(sleep);
}
}
}
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
Thread.Sleep(5000);
ForegroundCheckerWorker();
}
}
public void StatsUpdaterWorker()
{
// Wait here till mainform is up
while (Program.Mainform == null)
{
Thread.Sleep(100);
}
var usages = new CpuRamUsage();
var totalRam = PerformanceInfo.GetTotalMemory();
prepareMainGraphCpu();
prepareMainGraphMemory();
prepareMainGraphConnections();
prepareMainGraphGold();
while (true)
{
// Update Cpu/Ram Usage
usages.Update();
double diabloCpuUsage = 0;
long diabloRamUsage = 0;
int diabloCount = 0;
double demonbuddyCpuUsage = 0;
long demonbuddyRamUsage = 0;
int demonbuddyCount = 0;
double goldPerHour = 0;
double totalGold = 0;
foreach (var bot in BotSettings.Instance.Bots)
{
var chartStats = bot.ChartStats;
// Update bot uptime
bot.RunningTime = bot.IsRunning ? DateTime.Now.Subtract(bot.StartTime).ToString(@"hh\hmm\mss\s") : "";
// Update bot specific Chart stats
CreateChartStats(bot, Program.Mainform.GoldStats, ChartValueType.Double);
if (bot.IsRunning)
{
#region Calculate System Usage
if (bot.Diablo.IsRunning)
{
// Calculate total Cpu/Ram usage for Diablo
try
{
var usage = usages.GetUsageById(bot.Diablo.Proc.Id);
diabloCpuUsage += usage.Cpu;
diabloRamUsage += usage.Memory;
diabloCount++;
}
catch
{
}
}
if (bot.Demonbuddy.IsRunning)
{
// Calculate total Cpu/Ram usage for Demonbuddy
try
{
var usage = usages.GetUsageById(bot.Demonbuddy.Proc.Id);
demonbuddyCpuUsage += usage.Cpu;
demonbuddyRamUsage += usage.Memory;
demonbuddyCount++;
}
catch
{
}
}
#endregion
#region Gold Stats
chartStats.GoldStats.Update(bot); // Update Current bot
// Calculate total gold for all bots
goldPerHour += chartStats.GoldStats.GoldPerHour;
totalGold += chartStats.GoldStats.LastCoinage;
var serie = Program.Mainform.GoldStats.Series.FirstOrDefault(x => x.Name == bot.Name);
if (serie != null)
{
updateMainformGraph(Program.Mainform.GoldStats, serie.Name, Math.Round(chartStats.GoldStats.GoldPerHour), limit: (int)Properties.Settings.Default.StatsGphHistory, autoscale: true);
}
#endregion
}
else
{
}
}
try
{
// add to Cpu graph
var graph = Program.Mainform.CpuUsage;
var allusage = diabloCpuUsage + demonbuddyCpuUsage;
updateMainformGraph(graph, "All Usage", allusage, legend: string.Format("All usage: {0,11}%", allusage.ToString("000.0")), limit: (int)Properties.Settings.Default.StatsCPUHistory);
updateMainformGraph(graph, "Diablo", diabloCpuUsage, legend: string.Format("Diablo: {0,16}%", diabloCpuUsage.ToString("000.0")), limit: (int)Properties.Settings.Default.StatsCPUHistory);
updateMainformGraph(graph, "Demonbuddy", demonbuddyCpuUsage, legend: string.Format("Demonbuddy: {0,4}%", demonbuddyCpuUsage.ToString("000.0")), limit: (int)Properties.Settings.Default.StatsCPUHistory);
updateMainformGraph(graph, "Total System", Math.Round(usages.TotalCpuUsage, 2), legend: string.Format("Total System: {0,2}%", usages.TotalCpuUsage.ToString("000.0")), limit: (int)Properties.Settings.Default.StatsCPUHistory);
// add to Memory graph
graph = Program.Mainform.MemoryUsage;
allusage = (double)(diabloRamUsage + demonbuddyRamUsage) / totalRam * 100;
var diablousage = (double)diabloRamUsage / totalRam * 100;
var demonbuddyusage = (double)demonbuddyRamUsage / totalRam * 100;
updateMainformGraph(graph, "All Usage", allusage, legend: string.Format("All usage: {0,11}%", ((double)(diabloRamUsage + demonbuddyRamUsage) / totalRam * 100).ToString("000.0")), limit: (int)Properties.Settings.Default.StatsMemoryHistory);
updateMainformGraph(graph, "Diablo", diablousage, legend: string.Format("Diablo: {0,16}%", diablousage.ToString("000.0")), limit: (int)Properties.Settings.Default.StatsMemoryHistory);
updateMainformGraph(graph, "Demonbuddy", demonbuddyusage, legend: string.Format("Demonbuddy: {0,4}%", demonbuddyusage.ToString("000.0")), limit: (int)Properties.Settings.Default.StatsMemoryHistory);
var mem = (double)PerformanceInfo.GetPhysicalUsedMemory() / totalRam * 100;
updateMainformGraph(graph, "Total System", mem, legend: string.Format("Total System: {0,2}%", mem.ToString("000.0")), limit: (int)Properties.Settings.Default.StatsMemoryHistory);
// add to Connection graph
updateMainformGraph(Program.Mainform.CommConnections, "Connections", Communicator.StatConnections, legend: string.Format("Connections {0}", Communicator.StatConnections), autoscale: true, limit: (int)Properties.Settings.Default.StatsConnectionsHistory);
updateMainformGraph(Program.Mainform.CommConnections, "Failed", Communicator.StatFailed, legend: string.Format("Failed {0}", Communicator.StatFailed), autoscale: true, limit: (int)Properties.Settings.Default.StatsConnectionsHistory);
Communicator.StatConnections = 0;
Communicator.StatFailed = 0;
// add to Gold Graph
updateMainformGraph(Program.Mainform.GoldStats, "Gph", Math.Round(goldPerHour), legend: string.Format("Gph {0}", Math.Round(goldPerHour)), autoscale: true, limit: (int)Properties.Settings.Default.StatsGphHistory);
updateMainformLabel(Program.Mainform.CashPerHour, string.Format("{0:C2}", (goldPerHour / 1000000 * (double)Properties.Settings.Default.StatsGoldPrice)));
updateMainformLabel(Program.Mainform.CurrentCash, string.Format("{0:C2}", (totalGold / 1000000 * (double)Properties.Settings.Default.StatsGoldPrice)));
updateMainformLabel(Program.Mainform.TotalGold, string.Format("{0:N0}", totalGold));
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
Thread.Sleep((int)Properties.Settings.Default.StatsUpdateRate);
}
}
private void prepareMainGraphMemory()
{
if (Program.Mainform == null || Program.Mainform.MemoryUsage == null)
{
return;
}
try
{
Program.Mainform.Invoke(new Action(() =>
{
try
{
// Clear mainform stats
var graph = Program.Mainform.MemoryUsage;
graph.Series.Clear();
graph.Palette = ChartColorPalette.Pastel;
graph.Titles.Clear();
graph.Titles.Add("Memory Usage");
// Add Series
graph.Series.Add("All Usage");
graph.Series["All Usage"].ChartType = SeriesChartType.FastLine;
graph.Series["All Usage"].Points.Add(0);
graph.Series["All Usage"].YAxisType = AxisType.Primary;
graph.Series["All Usage"].YValueType = ChartValueType.Double;
graph.Series["All Usage"].IsXValueIndexed = false;
graph.Series["All Usage"].Color = Color.DarkSlateBlue;
graph.Series.Add("Demonbuddy");
graph.Series["Demonbuddy"].ChartType = SeriesChartType.FastLine;
graph.Series["Demonbuddy"].Points.Add(0);
graph.Series["Demonbuddy"].YAxisType = AxisType.Primary;
graph.Series["Demonbuddy"].YValueType = ChartValueType.Double;
graph.Series["Demonbuddy"].IsXValueIndexed = false;
graph.Series["Demonbuddy"].Color = Color.Red;
graph.Series.Add("Diablo");
graph.Series["Diablo"].ChartType = SeriesChartType.FastLine;
graph.Series["Diablo"].Points.Add(0);
graph.Series["Diablo"].YAxisType = AxisType.Primary;
graph.Series["Diablo"].YValueType = ChartValueType.Double;
graph.Series["Diablo"].IsXValueIndexed = false;
graph.Series["Diablo"].Color = Color.Green;
graph.Series.Add("Total System");
graph.Series["Total System"].ChartType = SeriesChartType.FastLine;
graph.Series["Total System"].Points.Add(0);
graph.Series["Total System"].YAxisType = AxisType.Primary;
graph.Series["Total System"].YValueType = ChartValueType.Double;
graph.Series["Total System"].IsXValueIndexed = false;
graph.Series["Total System"].Color = Color.SpringGreen;
graph.ResetAutoValues();
graph.ChartAreas[0].AxisY.Maximum = 100; //Max Y
graph.ChartAreas[0].AxisY.Minimum = 0;
graph.ChartAreas[0].AxisX.Enabled = AxisEnabled.False;
graph.ChartAreas[0].AxisY.IntervalAutoMode = IntervalAutoMode.VariableCount;
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}));
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
}
}
public void Start(bool noprofile = false, string profilepath = null, bool crashtenderstart = false)
{
if (!Parent.IsStarted || !Parent.Diablo.IsRunning || (_crashTenderRestart && !crashtenderstart))
{
return;
}
if (!File.Exists(Location))
{
Logger.Instance.Write("File not found: {0}", Location);
return;
}
while (Parent.IsStarted && Parent.Diablo.IsRunning)
{
// Get Last login time and kill old session
if (GetLastLoginTime)
{
BuddyAuth.Instance.KillSession(Parent);
}
_isStopped = false;
// Reset AntiIdle;
Parent.AntiIdle.Reset(true);
var arguments = "-pid=" + Parent.Diablo.Proc.Id;
arguments += " -key=" + Key;
arguments += " -autostart";
arguments += string.Format(" -routine=\"{0}\"", CombatRoutine);
arguments += string.Format(" -bnetaccount=\"{0}\"", Parent.Diablo.Username);
arguments += string.Format(" -bnetpassword=\"{0}\"", Parent.Diablo.Password);
if (profilepath != null)
{
// Check if current profile path is Kickstart
var file = Path.GetFileName(profilepath);
if (file == null || (file.Equals("YAR_Kickstart.xml") || file.Equals("YAR_TMP_Kickstart.xml")))
{
profilepath = Parent.ProfileSchedule.Current.Location;
}
var profile = new Profile()
{
Location = profilepath
};
var path = ProfileKickstart.GenerateKickstart(profile);
Logger.Instance.Write("Using Profile {0}", path);
arguments += string.Format(" -profile=\"{0}\"", path);
}
else if (Parent.ProfileSchedule.Profiles.Count > 0 && !noprofile)
{
var path = Parent.ProfileSchedule.GetProfile;
Logger.Instance.Write("Using Scheduled Profile {0}", path);
if (File.Exists(path))
{
arguments += string.Format(" -profile=\"{0}\"", path);
}
}
else if (!noprofile)
{
Logger.Instance.Write("Warning: Launching Demonbuddy without a starting profile (Add a profile to the profilescheduler for this bot)");
}
if (NoFlash)
{
arguments += " -noflash";
}
if (AutoUpdate)
{
arguments += " -autoupdate";
}
if (NoUpdate)
{
arguments += " -noupdate";
}
if (ForceEnableAllPlugins)
{
arguments += " -YarEnableAll";
}
Debug.WriteLine("DB Arguments: {0}", arguments);
var p = new ProcessStartInfo(Location, arguments)
{
WorkingDirectory = Path.GetDirectoryName(Location)
};
p = UserAccount.ImpersonateStartInfo(p, Parent);
// Check/Install latest Communicator plugin
var plugin = string.Format("{0}\\Plugins\\YAR\\Plugin.cs", p.WorkingDirectory);
if (!PluginVersionCheck.Check(plugin))
{
PluginVersionCheck.Install(plugin);
}
DateTime timeout;
try // Try to start Demonbuddy
{
Parent.Status = "Starting Demonbuddy"; // Update Status
Proc = Process.Start(p);
if (Program.IsRunAsAdmin)
{
Proc.PriorityClass = General.GetPriorityClass(Priority);
}
else
{
Logger.Instance.Write(Parent, "Failed to change priority (No admin rights)");
}
// Set affinity
if (CpuCount != Environment.ProcessorCount)
{
ProcessorAffinity = AllProcessors; // set it to all ones
CpuCount = Environment.ProcessorCount;
}
Proc.ProcessorAffinity = (IntPtr)ProcessorAffinity;
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Waiting for process to become ready", Proc.Id);
timeout = DateTime.Now;
while (true)
{
if (General.DateSubtract(timeout) > 30)
{
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Failed to start!", Proc.Id);
Parent.Restart();
return;
}
Thread.Sleep(500);
try
{
Proc.Refresh();
if (Proc.WaitForInputIdle(100) || CrashChecker.IsResponding(MainWindowHandle))
{
break;
}
}
catch
{
}
}
if (_isStopped)
{
return;
}
}
catch (Exception ex)
{
DebugHelper.Exception(ex);
Parent.Stop();
}
timeout = DateTime.Now;
while (!FindMainWindow())
{
if (General.DateSubtract(timeout) > 30)
{
MainWindowHandle = Proc.MainWindowHandle;
break;
}
Thread.Sleep(500);
}
// Window postion & resizing
if (ManualPosSize)
{
AutoPosition.ManualPositionWindow(MainWindowHandle, X, Y, W, H, Parent);
}
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Process is ready", Proc.Id);
// Wait for demonbuddy to be Initialized (this means we are logged in)
// If we don't wait here the Region changeing for diablo fails!
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Waiting for demonbuddy to log into Diablo", Proc.Id);
while (!IsInitialized && !_isStopped)
{
Thread.Sleep(1000);
}
// We made to many attempts break here
if (Parent.AntiIdle.FailedInitCount > 3)
{
break;
}
if (!Parent.AntiIdle.IsInitialized)
{
continue; // Retry
}
// We are ready to go
Logger.Instance.Write(Parent, "Demonbuddy:{0}: Initialized! We are ready to go", Proc.Id);
Parent.AntiIdle.FailedInitCount = 0; // only reset counter
break;
} // while (Parent.IsStarted && Parent.Diablo.IsRunning)
}
