public static void startBotting()
{
runningSmurfs.Clear();
if (accounts.Count < 1)
{
MessageBox.Show("Try to add smurfs before starting, ok?");
return;
}
int curRunning = 0;
started = true;
if (replaceConfig)
{
gamecfg();
}
int difVal = 0;
foreach (smurfData acc in accounts)
{
curRunning += 1;
QueueTypes queuetype = (QueueTypes)System.Enum.Parse(typeof(QueueTypes), qType);
long startTime = Stopwatch.GetTimestamp() + difVal * 10000;
RiotBot ritoBot = new RiotBot(acc.username, acc.password, acc.maxLevel, Region, gamePath, curRunning, queuetype, startTime);
difVal++;
runningSmurfs.Add(ritoBot);
if (curRunning == maxBots)
{
break;
}
}
}
public static void start()
{
ReloadAccounts:
loadAccounts();
int curRunning = 0;
foreach (string acc in accounts)
{
try
{
accounts2.RemoveAt(0);
string Accs = acc;
string[] stringSeparators = new string[] { "|" };
bool lead = false;
string token = "";
var result = Accs.Split(stringSeparators, StringSplitOptions.None);
curRunning += 1;
if (result[0].Contains("username"))
{
//Console.WriteLine("Please add your accounts into config\\accounts.txt");
goto ReloadAccounts;
}
/* if (result[3].Contains("Leader") || result.Contains("leader"))
* {
* lead = true;
* }*/
//Console.WriteLine(getTimestamp() + "Bot " + curRunning + " Waiting Launch Game From Garena");
token = GetGarenaToken();
if (result[1] != null)
{
QueueTypes queuetype = (QueueTypes)System.Enum.Parse(typeof(QueueTypes), result[1]);
RiotBot ritoBot = new RiotBot(result[0], token, Region, Path2, curRunning, queuetype, lead);
}
else
{
QueueTypes queuetype = QueueTypes.ARAM;
RiotBot ritoBot = new RiotBot(result[0], token, Region, Path2, curRunning, queuetype, lead);
}
Console.Title = "RitoBot Console | Currently connected: " + connectedAccs;
if (result[1] == "CUSTOM_HA_3x3")
{
while (!Program.IsGameCreated)
{
System.Threading.Thread.Sleep(1000);
}
}
if (curRunning == maxBots)
{
break;
}
}
catch (Exception)
{
//Console.WriteLine("CountAccError: You may have an issue in your accounts.txt");
Application.Exit();
}
}
}
public static void lognNewAccount()
{
accounts2 = accounts;
accounts.RemoveAt(0);
int curRunning = 0;
if (accounts.Count == 0)
{
Console.WriteLine(getTimestamp() + "No more accounts to login.");
}
foreach (string acc in accounts)
{
string Accs = acc;
string[] stringSeparators = new string[] { "|" };
var result = Accs.Split(stringSeparators, StringSplitOptions.None);
curRunning += 1;
if (result[2] != null)
{
QueueTypes queuetype = (QueueTypes)System.Enum.Parse(typeof(QueueTypes), result[2]);
Program ritoBot = new Program(result[0], result[1], Region, Path2, curRunning, queuetype);
}
else
{
QueueTypes queuetype = QueueTypes.ARAM;
Program ritoBot = new Program(result[0], result[1], Region, Path2, curRunning, queuetype);
}
Console.Title = " Current Connected: " + connectedAccs;
if (curRunning == maxBots)
{
break;
}
}
}
public async Task CreateQueueWriter(PlayerType playerType, QueueData queueData = null)
{
if (StaticResources.user.type == PlayerType.Host)
{
await QueueListner.DisconnectFromQueue();
}
if (QueueWriter != null)
{
await QueueWriter.DisconnectFromQueue();
}
QueueTypes queueTypes = new QueueTypes();
QueueData writerData = queueData;
if (playerType == PlayerType.Guest)
{
string queueName = "Join-" + StaticResources.sessionCode;
writerData = new QueueData();
writerData.queueName = queueName;
writerData.QueueConnectionString = ServiceBusData.ConnectionString;
}
// pass over connection data
QueueWriter = new QueueWriterHandler(writerData);
}
public void lognNewAccount()
{
accountsNew = accounts;
accounts.RemoveAt(0);
int curRunning = 0;
if (accounts.Count == 0)
{
updateStatus(msgStatus.INFO, "No more accounts to login.", "CONSOLE");
}
foreach (string acc in accounts)
{
string Accs = acc;
string[] stringSeparators = new string[] { "|" };
var result = Accs.Split(stringSeparators, StringSplitOptions.None);
curRunning += 1;
if (result[2] != null)
{
QueueTypes queuetype = (QueueTypes)System.Enum.Parse(typeof(QueueTypes), result[2]);
OldVoliBot ovb = new OldVoliBot(result[0], result[1], this, queuetype);
}
else
{
QueueTypes queuetype = QueueTypes.ARAM;
OldVoliBot ovb = new OldVoliBot(result[0], result[1], this, queuetype);
}
if (curRunning == maxBots)
{
break;
}
}
}
public void lognNewAccount()
{
this.accountsNew = this.accounts;
this.accounts.RemoveAt(0);
int num = 0;
if (this.accounts.Count == 0)
{
this.updateStatus(msgStatus.INFO, "No more accounts to login.", "CONSOLE");
}
foreach (string text in this.accounts)
{
string text2 = text;
string[] separator = new string[]
{
"|"
};
string[] array = text2.Split(separator, StringSplitOptions.None);
num++;
if (array[2] != null)
{
QueueTypes queue = (QueueTypes)Enum.Parse(typeof(QueueTypes), array[2]);
new OldVoliBot(array[0], array[1], this, queue);
}
else
{
QueueTypes queue2 = QueueTypes.ARAM;
new OldVoliBot(array[0], array[1], this, queue2);
}
if (num == this.maxBots)
{
break;
}
}
}
public static IFileTransferAdapter GetFileTransferAdapter(IAdaperSetting settings)
{
IFileTransferAdapter _adaptor;
_settings = settings;
QueueTypes type = (QueueTypes)Enum.Parse(typeof(QueueTypes), _settings.Type.Trim(), true);
switch (type)
{
case QueueTypes.SFTP:
_adaptor = new SFTPFileTransferAdapter(settings);
break;
case QueueTypes.FTP:
_adaptor = new FTPFileTransferAdapter(settings);
break;
case QueueTypes.SharedPath:
_adaptor = new LocalFileTransferAdapter(settings);
break;
case QueueTypes.LocalFileSystem:
_adaptor = new LocalFileTransferAdapter(settings);
break;
default:
throw new NotSupportedException(string.Format("{0} Transfer type not supported.", settings.Type));
}
return(_adaptor);
}
public static void lognNewAccount()
{
Config.accountsNew = Config.accounts;
Config.accounts.RemoveAt(0);
int num = 0;
if (Config.accounts.Count == 0)
{
Console.WriteLine(getTimestamp() + "No more accounts to login.");
}
foreach (string str in Config.accounts)
{
string[] separator = new string[] { "|" };
string[] strArray2 = str.Split(separator, StringSplitOptions.None);
num++;
if (strArray2[2] != null)
{
QueueTypes queueType = (QueueTypes)Enum.Parse(typeof(QueueTypes), strArray2[2]);
new VoliBot(strArray2[0], strArray2[1], Config.Region, Config.LauncherPath, queueType);
}
else
{
new VoliBot(strArray2[0], strArray2[1], Config.Region, Config.LauncherPath, QueueTypes.ARAM);
}
Console.Title = " Current Connected: " + Config.connectedAccs;
if (num == Config.maxBots)
{
break;
}
}
}
public ezBot(string username, string password, string reg, string path, QueueTypes QueueType, string LoLVersion)
{
ipath = path;
Accountname = username;
Password = password;
queueType = QueueType;
region = reg;
connection.OnConnect += new PvPNetConnection.OnConnectHandler(connection_OnConnect);
connection.OnDisconnect += new PvPNetConnection.OnDisconnectHandler(connection_OnDisconnect);
connection.OnError += new PvPNetConnection.OnErrorHandler(connection_OnError);
connection.OnLogin += new PvPNetConnection.OnLoginHandler(connection_OnLogin);
connection.OnLoginQueueUpdate += new PvPNetConnection.OnLoginQueueUpdateHandler(connection_OnLoginQueueUpdate);
connection.OnMessageReceived += new PvPNetConnection.OnMessageReceivedHandler(connection_OnMessageReceived);
switch (region)
{
case "EUW":
connection.Connect(username, password, Region.EUW, LoLVersion);
break;
case "EUNE":
connection.Connect(username, password, Region.EUN, LoLVersion);
break;
case "NA":
connection.Connect(username, password, Region.NA, LoLVersion);
break;
case "KR":
connection.Connect(username, password, Region.KR, LoLVersion);
break;
case "BR":
connection.Connect(username, password, Region.BR, LoLVersion);
break;
case "OCE":
connection.Connect(username, password, Region.OCE, LoLVersion);
break;
case "RU":
connection.Connect(username, password, Region.RU, LoLVersion);
break;
case "TR":
connection.Connect(username, password, Region.TR, LoLVersion);
break;
case "LAS":
connection.Connect(username, password, Region.LAS, LoLVersion);
break;
case "LAN":
connection.Connect(username, password, Region.LAN, LoLVersion);
break;
case "JP":
connection.Connect(username, password, Region.JP, LoLVersion);
break;
}
}
private static string GetMatchQueueTypeName(int queueId)
{
var queuetype = QueueTypes.FirstOrDefault(qt => qt.QueueId == queueId);
if (queuetype == null)
{
return("Undetermined");
}
var desc = queuetype.Description;
if (desc.Contains("Blind"))
{
return("Blind");
}
else if (desc.Contains("Draft"))
{
return("Draft");
}
else if (desc.Contains("Ranked Solo"))
{
return("Ranked Solo");
}
else if (desc.Contains("Ranked Flex"))
{
return("Ranked Flex");
}
else if (desc.Contains("ARAM"))
{
return("Aram");
}
return("Undetermined");
}
static void Main(string[] args)
{
Console.Title = "JAutoQueue";
Console.SetWindowSize(Console.WindowWidth + 5, Console.WindowHeight);
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("====================================================================================\n");
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" JAutoQueue | V2.0.0 for LoL 4.21.14_12_08_11_36 by Husmeador12\n");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("====================================================================================\n");
if (!isDonator)
{
Application.EnableVisualStyles();
Application.Run(new donate());
}
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(getTimestamp() + "Loading config.ini");
loadConfiguration();
if (replaceConfig)
{
Console.WriteLine(getTimestamp() + "Replacing Config");
gamecfg();
}
Console.WriteLine(getTimestamp() + "Loading accounts.txt");
loadAccounts();
int curRunning = 0;
foreach (string acc in accounts)
{
try
{
accounts2.RemoveAt(0);
string Accs = acc;
string[] stringSeparators = new string[] { "|" };
var result = Accs.Split(stringSeparators, StringSplitOptions.None);
curRunning += 1;
if (result[2] != null)
{
QueueTypes queuetype = (QueueTypes)System.Enum.Parse(typeof(QueueTypes), result[2]);
Program ritoBot = new Program(result[0], result[1], Region, Path2, curRunning, queuetype);
}
else
{
QueueTypes queuetype = QueueTypes.ARAM;
Program ritoBot = new Program(result[0], result[1], Region, Path2, curRunning, queuetype);
}
Console.Title = " Current Connected: " + connectedAccs;
if (curRunning == maxBots)
{
break;
}
}
catch (Exception)
{
Console.WriteLine("CountAccError: You may have an issue in your accounts.txt :(");
}
}
Console.ReadKey();
}
public RiotBot(string username, string password, string reg, string path, int threadid, QueueTypes QueueType)
{
ipath = path;
Accountname = username;
Password = password;
threadID = threadid;
queueType = QueueType;
region = reg;
connection.OnConnect += new LoLConnection.OnConnectHandler(this.connection_OnConnect);
connection.OnDisconnect += new LoLConnection.OnDisconnectHandler(this.connection_OnDisconnect);
connection.OnError += new LoLConnection.OnErrorHandler(this.connection_OnError);
connection.OnLogin += new LoLConnection.OnLoginHandler(this.connection_OnLogin);
connection.OnLoginQueueUpdate += new LoLConnection.OnLoginQueueUpdateHandler(this.connection_OnLoginQueueUpdate);
connection.OnMessageReceived += new LoLConnection.OnMessageReceivedHandler(this.connection_OnMessageReceived);
switch (region)
{
case "EUW":
connection.Connect(username, password, Region.EUW, "4.18.14_08_22_13_33");
break;
case "EUNE":
connection.Connect(username, password, Region.EUN, "4.18.14_08_22_13_33");
break;
case "NA":
connection.Connect(username, password, Region.NA, "4.18.14_08_22_13_33");
regionURL = "NA1";
break;
case "KR":
connection.Connect(username, password, Region.KR, "4.18.14_08_22_13_33");
break;
case "BR":
connection.Connect(username, password, Region.BR, "4.18.14_08_22_13_33");
break;
case "OCE":
connection.Connect(username, password, Region.OCE, "4.18.14_08_22_13_33");
break;
case "RU":
connection.Connect(username, password, Region.RU, "4.18.14_08_22_13_33");
break;
case "TR":
connection.Connect(username, password, Region.TR, "4.18.14_08_22_13_33");
break;
case "LAS":
connection.Connect(username, password, Region.LAS, "4.18.14_08_22_13_33");
break;
case "LAN":
connection.Connect(username, password, Region.LAN, "4.18.14_08_22_13_33");
break;
}
}
private static void Main(string[] args)
{
Console.SetWindowSize(Console.WindowWidth + 5, Console.WindowHeight);
Console.Title = "VoliBot - Auto Queue";
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("====================================================================================\n");
Console.WriteLine(string.Format("{0," + ((Console.WindowWidth / 2) + (Header1.Length / 2)) + "}", Header1));
Console.WriteLine(string.Format("{0," + ((Console.WindowWidth / 2) + (Header2.Length / 2)) + "}", Header2));
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(string.Format("{0," + ((Console.WindowWidth / 2) + (Header3.Length / 2)) + "}", Header3));
Console.WriteLine(string.Format("{0," + ((Console.WindowWidth / 2) + (Header3.Length / 2)) + "}", Header4));
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("====================================================================================\n");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(getTimestamp() + "Loading config.ini");
loadConfiguration();
if (Config.replaceConfig)
{
Console.WriteLine(getTimestamp() + "Replacing Config");
Basic.ReplaceGameConfig();
}
Console.WriteLine(getTimestamp() + "Loading accounts.txt");
loadAccounts();
int num = 0;
foreach (string str in Config.accounts)
{
try
{
Config.accountsNew.RemoveAt(0);
string str2 = str;
string[] separator = new string[] { "|" };
string[] strArray2 = str2.Split(separator, StringSplitOptions.None);
num++;
if (strArray2[2] != null)
{
QueueTypes queueType = (QueueTypes)Enum.Parse(typeof(QueueTypes), strArray2[2]);
new VoliBot(strArray2[0], strArray2[1], Config.Region, Config.LauncherPath, queueType);
}
else
{
new VoliBot(strArray2[0], strArray2[1], Config.Region, Config.LauncherPath, QueueTypes.ARAM);
}
Console.Title = " Current Connected: " + Config.connectedAccs;
if (num == Config.maxBots)
{
break;
}
}
catch (Exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("CountAccError: You may have an issue in your accounts.txt");
}
}
Console.ReadKey();
}
public async Task <List <QueueItem> > DequeueAsync(QueueTypes type, CancellationToken cancellationToken = default(CancellationToken))
{
var items = await _queueItemsRepository.GetPendingQueueItemsByTypeIdAsync((int)type);
foreach (var i in items)
{
i.PickedUp = DateTime.UtcNow;
await _queueItemsRepository.SaveOrUpdateAsync(i, cancellationToken);
}
return(items.ToList());
}
public async Task CreateQueueListner(PlayerType playerType)
{
QueueTypes queueTypes = new QueueTypes();
string queueName = playerType == PlayerType.Host ?
"Join-" + StaticResources.sessionCode :
"response-" + StaticResources.sessionCode + StaticResources.user.PlayerId.ToString();
QueueData listnerData = await QueueManipulator.validateExistance(queueName);
// pass over connection data
QueueListner = new QueueListnerHandler(listnerData);
}
static void Main(string[] args)
{
Console.Title = "RitoBot";
Console.SetWindowSize(Console.WindowWidth + 5, Console.WindowHeight);
Console.Write("====================================================================================\n");
Console.Write("VoliBot - MultiQueue | Version: 1.8.0 for LoL 4.18 by Maufeat\n");
Console.Write("====================================================================================\n");
Console.WriteLine(getTimestamp() + "Loading config.ini");
loadConfiguration();
if (replaceConfig)
{
Console.WriteLine(getTimestamp() + "Replacing Config");
gamecfg();
}
Console.WriteLine(getTimestamp() + "Loading accounts.txt");
loadAccounts();
int curRunning = 0;
foreach (string acc in accounts)
{
try
{
accounts2.RemoveAt(0);
string Accs = acc;
string[] stringSeparators = new string[] { "|" };
var result = Accs.Split(stringSeparators, StringSplitOptions.None);
curRunning += 1;
if (result[2] != null)
{
QueueTypes queuetype = (QueueTypes)System.Enum.Parse(typeof(QueueTypes), result[2]);
RiotBot ritoBot = new RiotBot(result[0], result[1], Region, Path2, curRunning, queuetype);
}
else
{
QueueTypes queuetype = QueueTypes.ARAM;
RiotBot ritoBot = new RiotBot(result[0], result[1], Region, Path2, curRunning, queuetype);
}
Console.Title = " Current Connected: " + connectedAccs;
if (curRunning == maxBots)
{
break;
}
}
catch (Exception)
{
Console.WriteLine("CountAccError: You may have an issue in your accounts.txt");
}
}
Console.ReadKey();
}
public void Init(String username, String pwd, LoLLauncher.Region reg, QueueTypes queuetype)
{
userName = username;
password = pwd;
queueType = queuetype;
region = reg;
connection.OnConnect += connection_OnConnect;
connection.OnDisconnect += connection_OnDisconnect;
connection.OnError += connection_OnError;
connection.OnLogin += connection_OnLogin;
connection.OnLoginQueueUpdate += connection_OnLoginQueueUpdate;
connection.OnMessageReceived += connection_OnMessageReceived;
updateStatus("Init");
}
public List <QueueItem> Dequeue(QueueTypes type)
{
var items = (from q in _queueItemsRepository.GetAll()
where q.QueueType == (int)type && q.PickedUp == null && q.CompletedOn == null
select q).ToList();
foreach (var i in items)
{
i.PickedUp = DateTime.Now.ToUniversalTime();
_queueItemsRepository.SaveOrUpdate(i);
}
return(items);
}
private void console_Load(object sender, EventArgs e)
{
this.updateStatus(msgStatus.INFO, "Console initialized.", "CONSOLE");
if (this.replaceConfig)
{
this.updateStatus(msgStatus.INFO, "Replacing Config.", "CONSOLE");
try
{
Basic.ReplaceGameConfig(this.lolPath);
}
catch (Exception)
{
}
}
this.updateStatus(msgStatus.INFO, "Loading Accounts", "CONSOLE");
this.loadAccounts();
int num = 0;
foreach (string text in this.accounts)
{
try
{
this.accountsNew.RemoveAt(0);
string[] separator = new string[]
{
"|"
};
string[] array = text.Split(separator, StringSplitOptions.None);
num++;
if (array[2] != null)
{
QueueTypes queue = (QueueTypes)Enum.Parse(typeof(QueueTypes), array[2]);
new OldVoliBot(array[0], array[1], this, queue);
}
else
{
QueueTypes queue2 = QueueTypes.ARAM;
new OldVoliBot(array[0], array[1], this, queue2);
}
if (num == this.maxBots)
{
break;
}
}
catch (Exception ex)
{
this.updateStatus(msgStatus.ERROR, "错误:你的Accounts.txt里面格式可能错误" + ex.Message, "CONSOLE");
}
}
}
public void Init(String username, String pwd, LoLLauncher.Region reg, QueueTypes queuetype)
{
userName = username;
password = pwd;
queueType = queuetype;
region = reg;
connection.OnConnect += connection_OnConnect;
connection.OnDisconnect += connection_OnDisconnect;
connection.OnError += connection_OnError;
connection.OnLogin += connection_OnLogin;
connection.OnLoginQueueUpdate += connection_OnLoginQueueUpdate;
connection.OnMessageReceived += connection_OnMessageReceived;
updateStatus("Init");
}
public OldVoliBot(string username, string password, console _parent, QueueTypes queue)
{
parent = _parent;
ipath = parent.lolPath; Accountname = username; Password = password; queueType = queue;
baseRegion = BaseRegion.GetRegion(_parent.region.ToString());
connection.OnConnect += new LoLConnection.OnConnectHandler(connection_OnConnect);
connection.OnDisconnect += new LoLConnection.OnDisconnectHandler(connection_OnDisconnect);
connection.OnError += new LoLConnection.OnErrorHandler(connection_OnError);
connection.OnLogin += new LoLConnection.OnLoginHandler(connection_OnLogin);
connection.OnLoginQueueUpdate += new LoLConnection.OnLoginQueueUpdateHandler(connection_OnLoginQueueUpdate);
connection.OnMessageReceived += new LoLConnection.OnMessageReceivedHandler(connection_OnMessageReceived);
string pass = Regex.Replace(password, @"\s+", "");
connection.Connect(Accountname, pass, baseRegion.PVPRegion, _parent.currentVersion + "." + Config.clientSubVersion);
}
public LoLLauncherClient(String username, String pwd, LoLLauncher.Region reg, QueueTypes queuetype, IntPtr panelhnd, String installExe)
{
panelHandle = panelhnd;
userName = username;
password = pwd;
queueType = queuetype;
region = reg;
connection.OnConnect += connection_OnConnect;
connection.OnDisconnect += connection_OnDisconnect;
connection.OnError += connection_OnError;
connection.OnLogin += connection_OnLogin;
connection.OnLoginQueueUpdate += connection_OnLoginQueueUpdate;
connection.OnMessageReceived += connection_OnMessageReceived;
installPath = installExe;
updateStatus("Init");
}
public LoLLauncherClient(String username, String pwd, LoLLauncher.Region reg, QueueTypes queuetype, IntPtr panelhnd, String installExe)
{
panelHandle = panelhnd;
userName = username;
password = pwd;
queueType = queuetype;
region = reg;
connection.OnConnect += connection_OnConnect;
connection.OnDisconnect += connection_OnDisconnect;
connection.OnError += connection_OnError;
connection.OnLogin += connection_OnLogin;
connection.OnLoginQueueUpdate += connection_OnLoginQueueUpdate;
connection.OnMessageReceived += connection_OnMessageReceived;
installPath = installExe;
updateStatus("Init");
}
public Program(string username, string password, string region, string path, int threadid, QueueTypes QueueType)
{
ipath = path; Accountname = username; Password = password; threadID = threadid; queueType = QueueType;
regiona = region;
connection.OnConnect += new LoLConnection.OnConnectHandler(connection_OnConnect);
connection.OnDisconnect += new LoLConnection.OnDisconnectHandler(connection_OnDisconnect);
connection.OnError += new LoLConnection.OnErrorHandler(connection_OnError);
connection.OnLogin += new LoLConnection.OnLoginHandler(connection_OnLogin);
connection.OnLoginQueueUpdate += new LoLConnection.OnLoginQueueUpdateHandler(connection_OnLoginQueueUpdate);
connection.OnMessageReceived += new LoLConnection.OnMessageReceivedHandler(connection_OnMessageReceived);
switch (region)
{
case "EUW":
connection.Connect(username, password, Region.EUW, "4.21.14_12_08_11_36");
break;
case "EUNE":
connection.Connect(username, password, Region.EUN, "4.21.14_12_08_11_36");
break;
case "BR":
connection.Connect(username, password, Region.BR, "4.21.14_12_08_11_36");
break;
case "KR":
connection.Connect(username, password, Region.KR, "4.21.14_12_08_11_36");
break;
case "OCE":
connection.Connect(username, password, Region.OCE, "4.21.14_12_08_11_36");
break;
case "NA":
connection.Connect(username, password, Region.NA, "4.21.14_12_08_11_36");
break;
case "TR":
connection.Connect(username, password, Region.TR, "4.21.14_12_08_11_36");
break;
case "TW":
connection.Connect(username, password, Region.TW, "4.21.14_12_08_11_36");
break;
case "RU":
connection.Connect(username, password, Region.RU, "4.21.14_12_08_11_36");
break;
case "LAN":
connection.Connect(username, password, Region.LAN, "4.21.14_12_08_11_36");
break;
case "LAS":
connection.Connect(username, password, Region.LAS, "4.21.14_12_08_11_36");
break;
}
}
private void queueLoop()
{
foreach (string acc in Program.accounts)
{
int curRunning = 0;
try
{
Program.accounts2.RemoveAt(0);
string Accs = acc;
string[] stringSeparators = new string[] { "|" };
var result = Accs.Split(stringSeparators, StringSplitOptions.None);
console.ForeColor = Color.Lime;
curRunning += 1;
if (result[0].Contains("username"))
{
Print("No accounts found. Please add an account.", 2);
}
if (result[2] != null)
{
QueueTypes queuetype = (QueueTypes)System.Enum.Parse(typeof(QueueTypes), result[2]);
// RiotBot ritoBot = new RiotBot(result[0], result[1], Program.Region, Program.Path2, curRunning, queuetype, result[3]);
ShowAccount(result[0], result[1], result[2]);
}
else
{
QueueTypes queuetype = QueueTypes.ARAM;
//RiotBot ritoBot = new RiotBot(result[0], result[1], Program.Region, Program.Path2, curRunning, queuetype, result[3]);
ShowAccount(result[0], result[1], "ARAM");
}
Program.MainWindow.Text = " Volibot GUI | Currently connected: " + Program.connectedAccs;
if (curRunning == Program.maxBots)
{
break;
}
}
catch (Exception)
{
console.ForeColor = Color.Red;
Print("You may have an error in accounts.txt.");
Print("If you just started Volibot for the first time,");
Print("add a new account on the leftside panel.");
Print("If you keep getting this error,");
Print("Delete accounts.txt and restart voli.", 2);
}
}
}
private void console_Load(object sender, EventArgs e)
{
updateStatus(msgStatus.INFO, "Console initialized.", "CONSOLE");
if (replaceConfig)
{
updateStatus(msgStatus.INFO, "Replacing Config.", "CONSOLE");
try
{
Basic.ReplaceGameConfig(lolPath);
}
catch (Exception) { }
}
updateStatus(msgStatus.INFO, "Loading Accounts", "CONSOLE");
loadAccounts();
int curRunning = 0;
foreach (string acc in accounts)
{
try
{
accountsNew.RemoveAt(0);
string[] stringSeparators = new string[] { "|" };
var result = acc.Split(stringSeparators, StringSplitOptions.None);
curRunning += 1;
if (result[2] != null)
{
QueueTypes queuetype = (QueueTypes)System.Enum.Parse(typeof(QueueTypes), result[2]);
OldVoliBot ovb = new OldVoliBot(result[0], result[1], this, queuetype);
}
else
{
QueueTypes queuetype = QueueTypes.ARAM;
OldVoliBot ovb = new OldVoliBot(result[0], result[1], this, queuetype);
}
if (curRunning == maxBots)
{
break;
}
}
catch (Exception ex)
{
updateStatus(msgStatus.ERROR, "CountAccError: You may have an issue in your accounts.txt" + ex.Message, "CONSOLE");
}
}
}
public static void lognNewAccount()
{
accounts2 = accounts;
accounts.RemoveAt(0);
int curRunning = 0;
if (accounts.Count == 0)
{
Console.WriteLine(getTimestamp() + "No more accounts to login.");
}
foreach (string acc in accounts)
{
string Accs = acc;
string[] stringSeparators = new string[] { "|" };
var result = Accs.Split(stringSeparators, StringSplitOptions.None);
curRunning += 1;
bool lead = false;
string token = "";
/* if (result[3].Contains("Leader") || result.Contains("leader"))
* {
* lead = true;
* }*/
Console.WriteLine("Waiting Launch Game From Garena");
token = GetGarenaToken();
Console.WriteLine("Get Token!");
if (result[1] != null)
{
QueueTypes queuetype = (QueueTypes)System.Enum.Parse(typeof(QueueTypes), result[1]);
RiotBot ritoBot = new RiotBot(result[0], token, Region, Path2, curRunning, queuetype, lead);
}
else
{
QueueTypes queuetype = QueueTypes.ARAM;
RiotBot ritoBot = new RiotBot(result[0], token, Region, Path2, curRunning, queuetype, lead);
}
Console.Title = "RitoBot Console | Currently connected: " + connectedAccs;
if (curRunning == maxBots)
{
break;
}
}
}
public bool AddQueue <T>(QueueTypes type, T message)
{
try
{
CloudStorageAccount storage = CloudStorageAccount.Parse(StorageOptions.ConnectionString);
var queueClient = storage.CreateCloudQueueClient();
var queueRef = queueClient.GetQueueReference(type.GetDescriptionString());
queueRef.CreateIfNotExistsAsync().Wait();
queueRef.AddMessageAsync(new Microsoft.WindowsAzure.Storage.Queue.CloudQueueMessage(JsonConvert.SerializeObject(message))).Wait();
GC.SuppressFinalize(queueRef);
GC.SuppressFinalize(queueClient);
GC.SuppressFinalize(storage);
return(true);
}
catch { return(false); }
}
public static MsCrmResultObject GetQueues(QueueTypes type, SqlDataAccess sda)
{
MsCrmResultObject returnValue = new MsCrmResultObject();
try
{
#region | SQL QUERY |
string query = @"SELECT
Q.QueueId
,Q.Name
FROM
Queue Q WITH (NOLOCK)
WHERE
Q.StateCode = 0
AND
Q.new_queuetype = {0}" ;
#endregion
DataTable dt = sda.getDataTable(string.Format(query, (int)type));
if (dt != null && dt.Rows.Count > 0)
{
List <Queue> returnList = new List <Queue>();
for (int i = 0; i < dt.Rows.Count; i++)
{
Queue _queue = new Queue();
_queue.QueueId = (Guid)dt.Rows[i]["QueueId"];
_queue.Name = dt.Rows[i]["Name"] != DBNull.Value ? dt.Rows[i]["Name"].ToString() : string.Empty;
returnList.Add(_queue);
}
returnValue.Success = true;
returnValue.ReturnObject = returnList;
}
}
catch (Exception ex)
{
returnValue.Success = false;
returnValue.Result = ex.Message;
}
return(returnValue);
}
public RiotBot(string username, string password, string reg, string path, int threadid, QueueTypes QueueType, bool lead)
{
ipath = path;
Accountname = username;
Password = password;
threadID = threadid;
queueType = QueueType;
region = reg;
leader = lead;
connection.OnConnect += new LoLConnection.OnConnectHandler(this.connection_OnConnect);
connection.OnDisconnect += new LoLConnection.OnDisconnectHandler(this.connection_OnDisconnect);
connection.OnError += new LoLConnection.OnErrorHandler(this.connection_OnError);
connection.OnLogin += new LoLConnection.OnLoginHandler(this.connection_OnLogin);
connection.OnLoginQueueUpdate += new LoLConnection.OnLoginQueueUpdateHandler(this.connection_OnLoginQueueUpdate);
connection.OnMessageReceived += new LoLConnection.OnMessageReceivedHandler(this.connection_OnMessageReceived);
switch (region)
{
case "TH":
connection.Connect(username, password, Region.TH, Program.cversion);
break;
case "SGMY":
connection.Connect(username, password, Region.SGMY, Program.cversion);
break;
case "TW":
connection.Connect(username, password, Region.TW, Program.cversion);
break;
case "PH":
connection.Connect(username, password, Region.PH, Program.cversion);
break;
case "VN":
connection.Connect(username, password, Region.VN, Program.cversion);
break;
case "ID":
connection.Connect(username, password, Region.ID, Program.cversion);
break;
}
}
public RiotBot(string username, string password, string accmaxlevel, string reg, string path, int threadid, QueueTypes QueueType, long starttime)
{
ipath = path;
Accountname = username;
Password = password;
AccMaxLevel = Convert.ToInt32(accmaxlevel);
threadID = threadid;
queueType = QueueType;
startTime = starttime;
region = reg;
connection.OnConnect += new LoLConnection.OnConnectHandler(this.connection_OnConnect);
connection.OnDisconnect += new LoLConnection.OnDisconnectHandler(this.connection_OnDisconnect);
connection.OnError += new LoLConnection.OnErrorHandler(this.connection_OnError);
connection.OnLogin += new LoLConnection.OnLoginHandler(this.connection_OnLogin);
connection.OnLoginQueueUpdate += new LoLConnection.OnLoginQueueUpdateHandler(this.connection_OnLoginQueueUpdate);
connection.OnMessageReceived += new LoLConnection.OnMessageReceivedHandler(this.connection_OnMessageReceived);
init(region, username, password);
}
public void CreateQueueWriter(PlayerType playerType, QueueData queueData = null)
{
if (QueueWriter != null)
{
QueueWriter.DisconnectFromQueue();
}
QueueTypes queueTypes = new QueueTypes();
QueueData writerData = queueData;
if (playerType == PlayerType.Guest)
{
string queueName = "Join-" + StaticResources.sessionCode;
writerData = QueueManipulator.CreateNewQueue(queueName);
}
// pass over connection data
QueueWriter = new QueueWriterHandler(writerData);
}
public RiotBot(string username, string password, int accmaxlevel, string reg, string path, QueueTypes QueueType, string cMask, Smurf own)
{
ipath = path;
Accountname = username;
Password = password;
clientMask = cMask;
AccMaxLevel = Convert.ToInt32(accmaxlevel);
queueType = QueueType;
region = reg;
Owner = own;
this.updateStatus("Trying to login...", Accountname);
connection.OnError += new LoLConnection.OnErrorHandler(this.connection_OnError);
connection.OnLogin += new LoLConnection.OnLoginHandler(this.connection_OnLogin);
connection.OnLoginQueueUpdate += new LoLConnection.OnLoginQueueUpdateHandler(this.connection_OnLoginQueueUpdate);
connection.OnMessageReceived += new LoLConnection.OnMessageReceivedHandler(this.connection_OnMessageReceived);
init(region, username, password);
}
void connection_OnLogin(object sender, string username, string ipAddress)
{
new Thread(async delegate()
{
RegisterNotifications();
loginPacket = await connection.GetLoginDataPacketForUser();
//
/*FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = @"..\Common\";
watcher.Filter = "summoner_" + loginPacket.AllSummonerData.Summoner.Name + "_finished.txt";
watcher.NotifyFilter = NotifyFilters.LastAccess |
NotifyFilters.LastWrite |
NotifyFilters.FileName |
NotifyFilters.DirectoryName;
watcher.Created += watcher_Created;
watcher.EnableRaisingEvents = true;*/
if (loginPacket.AllSummonerData == null)
{
Random rnd = new Random();
String summonerName = username;
if (summonerName.Length > 16)
summonerName = summonerName.Substring(0, 12) + new Random().Next(1000, 9999).ToString();
LoLLauncher.RiotObjects.Platform.Summoner.AllSummonerData sumData = await connection.CreateDefaultSummoner(summonerName);
loginPacket.AllSummonerData = sumData;
}
updateStatus("Logged in on " + loginPacket.AllSummonerData.Summoner.Name);
updateStatus("Starting at lvl " + loginPacket.AllSummonerData.SummonerLevel.Level);
if (loginPacket.AllSummonerData.SummonerLevel.Level < 6 && queueType == QueueTypes.ARAM)
{
updateStatus("Need to lvl up before ARAM. Defaulting to intro bots");
queueType = QueueTypes.INTRO_BOT;
}
updateStatus("Starting with " + loginPacket.IpBalance + "ip");
LoLLauncher.RiotObjects.Platform.Matchmaking.GameQueueConfig[] availableQueues = await connection.GetAvailableQueues();
//LoLLauncher.RiotObjects.Platform.Summoner.Boost.SummonerActiveBoostsDTO boosts = await connection.GetSumonerActiveBoosts();
//LoLLauncher.RiotObjects.Platform.Leagues.Client.Dto.SummonerLeagueItemAndProgresssDTO leaguePosProg = await connection.GetMyLeaguePositionsAndProgress();
availableChampsArray = await connection.GetAvailableChampions();
LoLLauncher.RiotObjects.Platform.Summoner.Runes.SummonerRuneInventory sumRuneInven = await connection.GetSummonerRuneInventory(loginPacket.AllSummonerData.Summoner.SumId);
LoLLauncher.RiotObjects.Platform.Leagues.Client.Dto.SummonerLeagueItemsDTO leaguePos = await connection.GetMyLeaguePositions();
object preferences = await connection.LoadPreferencesByKey("KEY BINDINGS", 1, false);
LoLLauncher.RiotObjects.Platform.Summoner.Masterybook.MasteryBookDTO masteryBook = await connection.GetMasteryBook(loginPacket.AllSummonerData.Summoner.SumId);
LoLLauncher.RiotObjects.Team.Dto.PlayerDTO player = await connection.CreatePlayer();
if (loginPacket.ReconnectInfo != null && loginPacket.ReconnectInfo.Game != null)
{
updateStatus("Reconnecting to game");
connection_OnMessageReceived(sender, loginPacket.ReconnectInfo.PlayerCredentials);
}
else
{
if (queueType == QueueTypes.CUSTOM)
{
CreatePracticeGame();
}
else
{
LoLLauncher.RiotObjects.Platform.Statistics.EndOfGameStats eog = new LoLLauncher.RiotObjects.Platform.Statistics.EndOfGameStats();
connection_OnMessageReceived(sender, eog);
}
}
}).Start();
}
private string GetQueueNameFromType(QueueTypes type)
{
// Make up a name based on the enum and namespace
string name = string.Format(CultureInfo.CurrentCulture, "{0}.{1}", type.GetType().FullName, type);
// Queue names in azure must be lower case
name = name.ToLower(CultureInfo.CurrentCulture);
// No '.' allow in the name
name = name.Replace('.', '-');
return name;
}
/// <summary>
/// Get the challenger league for specified queue type.
/// </summary>
/// <param name="queueType">The queue type enum.</param>
/// <param name="callback">The callback method.</param>
public void GetChallengerLeague(QueueTypes queueType, League.Callback callback)
{
League cb = new League(callback);
InvokeWithCallback("leaguesServiceProxy", "getChallengerLeague", new object[] { StringEnum.GetStringValue(queueType) }, cb);
}
private void connection_OnLogin(object sender, string username, string ipAddress)
{
new Thread((ThreadStart)(async () =>
{
updateStatus("Connecting...", Accountname);
loginPacket = await connection.GetLoginDataPacketForUser();
await connection.Subscribe("bc", loginPacket.AllSummonerData.Summoner.AcctId);
await connection.Subscribe("cn", loginPacket.AllSummonerData.Summoner.AcctId);
await connection.Subscribe("gn", loginPacket.AllSummonerData.Summoner.AcctId);
if (loginPacket.AllSummonerData == null)
{
Random rnd = new Random();
String summonerName = Accountname;
if (summonerName.Length > 16)
summonerName = summonerName.Substring(0, 12) + new Random().Next(1000, 9999).ToString();
await connection.CreateDefaultSummoner(summonerName);
updateStatus("Created Summoner: " + summonerName, Accountname);
}
sumLevel = loginPacket.AllSummonerData.SummonerLevel.Level;
string sumName = loginPacket.AllSummonerData.Summoner.Name;
double sumId = loginPacket.AllSummonerData.Summoner.SumId;
rpBalance = loginPacket.RpBalance;
if (sumLevel > Core.maxLevel || sumLevel == Core.maxLevel)
{
connection.Disconnect();
updateStatus("Summoner: " + sumName + " is already max level.", Accountname);
updateStatus("Log into new account.", Accountname);
Core.lognNewAccount();
return;
}
if (rpBalance == 400.0 && Core.buyBoost)
{
updateStatus("Buying XP Boost", Accountname);
try
{
Task t = new Task(buyBoost);
t.Start();
}
catch (Exception exception)
{
updateStatus("Couldn't buy RP Boost.\n" + exception, Accountname);
}
}
if (sumLevel < 3.0 && queueType == QueueTypes.NORMAL_5x5)
{
this.updateStatus("Need to be Level 3 before NORMAL_5x5 queue.", Accountname);
this.updateStatus("Joins Co-Op vs AI (Beginner) queue until 3", Accountname);
queueType = QueueTypes.BEGINNER_BOT;
actualQueueType = QueueTypes.NORMAL_5x5;
}
else if (sumLevel < 6.0 && queueType == QueueTypes.ARAM)
{
this.updateStatus("Need to be Level 6 before ARAM queue.", Accountname);
this.updateStatus("Joins Co-Op vs AI (Beginner) queue until 6", Accountname);
queueType = QueueTypes.BEGINNER_BOT;
actualQueueType = QueueTypes.ARAM;
}
else if (sumLevel < 7.0 && queueType == QueueTypes.NORMAL_3x3)
{
this.updateStatus("Need to be Level 7 before NORMAL_3x3 queue.", Accountname);
this.updateStatus("Joins Co-Op vs AI (Beginner) queue until 7", Accountname);
queueType = QueueTypes.BEGINNER_BOT;
actualQueueType = QueueTypes.NORMAL_3x3;
}
if (loginPacket.AllSummonerData.Summoner.ProfileIconId == -1 || loginPacket.AllSummonerData.Summoner.ProfileIconId == 1)
{
double[] ids = new double[Convert.ToInt32(sumId)];
string icons = await connection.GetSummonerIcons(ids);
List<int> availableIcons = new List<int> { };
var random = new Random();
for (int i = 0; i < 29; i++)
{
availableIcons.Add(i);
}
foreach (var id in icons)
{
availableIcons.Add(Convert.ToInt32(id));
}
int index = random.Next(availableIcons.Count);
int randomIcon = availableIcons[index];
await connection.UpdateProfileIconId(randomIcon);
}
updateStatus("Logged in as " + loginPacket.AllSummonerData.Summoner.Name + " @ level " + loginPacket.AllSummonerData.SummonerLevel.Level, Accountname);
availableChampsArray = await connection.GetAvailableChampions();
PlayerDTO player = await connection.CreatePlayer();
if (loginPacket.ReconnectInfo != null && loginPacket.ReconnectInfo.Game != null)
{
connection_OnMessageReceived(sender, (object)loginPacket.ReconnectInfo.PlayerCredentials);
}
else
connection_OnMessageReceived(sender, (object)new EndOfGameStats());
})).Start();
}
