rendered paste bodyusing System;
using System.Collections.Generic;
using System.Text;
using D2Sniffer;
using System.Diagnostics;
using System.Net.Sockets;
namespace data
{
public class Bot
{
//fields
BotConfig myBotConfig; //configuration for current bot instance
static PacketSniffer myPacketSniffer; //d2Smell sniffer instance
TcpClient myBnetServerClient, myRealmServerClient,myGameServerClient;//connections to battle.net servers
static System.Net.IPAddress RealmServerIp; //Used as storage to connect to realmserver after the response from BNLS is received
ushort CurrentGameNum = 0; //used in CreateGame packet, increment by 0x02 each game
uint ClientToken, ServerToken; //Tokens used to Hash data at run-time
//TODO change this when implementing the cdkey files and store the damn index cuz appsettings are so retarded...
int KeyListIndex = 0; //keep track of the current used cdkey
string RealmServerString, BNCSUniqueName, CurrentGameName, CurrentGamePassword = "sadsapog"; //game related + internal stuff
bool LoginDone = false, InGame = false, FailedToJoin = false; //used in the Creat/Join game proc
byte[] RSLogon; //a packet that is built in a function but sent in another one.
int RunCreationWaitDelay = 5000; //the delay between each game creation attemps
public int TotalRuns = 0, TotalCompletedRuns = 0; //runs state: TotalCompletedRuns/TotalRuns
public RealmServer.JoinGameResult LastJoinResult = RealmServer.JoinGameResult.Success;
public bool NeedIPReset = false; //this is not yet set
private bool FatalDebugError = false; //replace this eventually; (or I might keep it)
/// <summary>
/// Ctor
/// </summary>
/// <param name="botConfig">a BotConfig object containing all revelant information to run the bot</param>
public Bot(BotConfig botConfig)
{
this.myBotConfig = botConfig; //keep this
}
int TotalTimeOutGame = 0;
/// <summary>
/// Will perform a hard-coded number of runs. Then return to change cdkey
/// Caution: Some runs use 2 games but are considered being only 1run (when the bot use ComeBack if 2000 received packets is reached)
/// So be carefull since if you set it to swap cdkey every 20runs it can create up to 40 games
/// </summary>
public void doRuns()
{
this.NeedIPReset = false;
//myPacketSniffer.OnConnectionChange += new ConnectionChangeHandler(myPacketSniffer_OnConnectionChange);
CurrentGameNum = 0; //increment by 2 at each game creation
Game.PacketDispatcher myPacketDispatcher = new data.Game.PacketDispatcher();
myPacketSniffer.AddListener(D2Packets.PacketOrigin.GameServer, new PacketEventHandler(myPacketDispatcher.onPacketArrival));
int InitialTicks = 0;
Test myTest = new Test(myBotConfig, false);
//for (int i = 0; i < 10; i++)
int i = 0;
while (true)
{
if (i > 0)
{
//Disconnect_BnetServer();
//Disconnect_RealmServer();
onRunDone();
}
i++;
//if (this.NeedIPReset)
// return;
Game.GameInfo.RST = false;
CurrentGameNum += 2;
this.FailedToJoin = false;
this.InGame = false;
Random rnd = new Random();
Sleep(this.RunCreationWaitDelay);
Game.Belt.Init();
CurrentGameName = rnd.Next(1000000, 99999999).ToString();
CreateGame(CurrentGameNum, CurrentGameName, CurrentGamePassword, DifficultyType.Nightmare, "");
//JoinGame(1, "Dkk3", "Q");
int Timeout2 = 0;
//while (!this.FatalDebugError && !this.InGame)
while (!this.InGame)
{
System.Threading.Thread.Sleep(1);
Timeout2++;
if (Timeout2 > 5000)
{
if (TotalTimeOutGame > 20)
return;
Sleep(5000);
TotalTimeOutGame++;
Logger.Log("Bot(): Create game timed out");
break; ;
}
if (this.FailedToJoin)
{
//Sleep(30000);
Sleep(5000);
this.FailedToJoin = false;
break;
}
}
if (!this.InGame)
{
//onRunDone();
continue;
}
TotalTimeOutGame = 0;
InitialTicks = Environment.TickCount;
//Sleep(100);
//if (Game.GameInfo.RST)
//{
// Logger.Log("RST, create new game");
// continue;
//}
bool RunSuccess = false;
try
{
RunSuccess = myTest.DoRun(ref myGameServerClient);
}
catch
{
this.TotalRuns += 1;
myTest.onRunDone();
continue;
}
if (RunSuccess)
this.TotalCompletedRuns += 1;
this.TotalRuns += 1;
myTest.onRunDone();
//go back to the same game in case we did not finish the run under 2000 rcv packets
if (!RunSuccess && Game.GameInfo.Catacomb2Path.Count > 0 && Game.GameInfo.Catacomb3Path.Count == 0)
{
onRunDone();
Game.Belt.Init();
Game.GameInfo.RST = false;
CurrentGameNum += 2;
this.FailedToJoin = false;
this.InGame = false;
LastJoinResult = RealmServer.JoinGameResult.Success;
Sleep(2000);
for (int ia = 0; ia < 3; ia++)
{
if (ia > 0)
Sleep(this.RunCreationWaitDelay);
JoinGame(this.CurrentGameNum, this.CurrentGameName, this.CurrentGamePassword);
for (int tt = 0; tt < 1000; tt++)
{
Sleep(1);
if (this.InGame)
break;
if (this.FailedToJoin)
continue;
}
if (this.InGame)
break;
if (LastJoinResult == RealmServer.JoinGameResult.GameDoesNotExist)
break;
}
//Sleep(1000);
if (!this.InGame)
continue;
try
{
if (myTest.ComeBack(ref myGameServerClient))
this.TotalCompletedRuns += 1;
}
catch
{
}
}
//go back to the same game in case we did not finish the run under 2000 rcv packets
if (!RunSuccess && Game.GameInfo.Catacomb2Path.Count > 0 && Game.GameInfo.Catacomb3Path.Count > 0)
{
onRunDone();
Game.Belt.Init();
Game.GameInfo.RST = false;
CurrentGameNum += 2;
this.FailedToJoin = false;
this.InGame = false;
LastJoinResult = RealmServer.JoinGameResult.Success;
Sleep(2000);
for (int ia = 0; ia < 3; ia++)
{
if (ia > 0)
Sleep(this.RunCreationWaitDelay);
JoinGame(this.CurrentGameNum, this.CurrentGameName, this.CurrentGamePassword);
for (int tt = 0; tt < 1000; tt++)
{
Sleep(1);
if (this.InGame)
break ;
//break;
if (this.FailedToJoin)
continue;
}
if (this.InGame)
break;
if (LastJoinResult == RealmServer.JoinGameResult.GameDoesNotExist)
break;
}
//Sleep(1000);
if (!this.InGame)
continue;
try
{
if (myTest.ComeBack(ref myGameServerClient))
this.TotalCompletedRuns += 1;
}
catch
{
}
}
Logger.Log("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
Logger.Log("Total completed runs: " + this.TotalCompletedRuns + " on " + this.TotalRuns);
Logger.Log("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
if (FatalDebugError)
{
Logger.Log("Fatal error, trying to reconnect to bnet");
onRunDone();
//continue;
}
}
}
public void CheckCdKeys()
{
if (!System.IO.File.Exists(Environment.CurrentDirectory + "\\system\\State\\" + this.myBotConfig._CharacterName))
System.IO.File.Create(Environment.CurrentDirectory + "\\system\\State\\" + this.myBotConfig._CharacterName).Close();
System.IO.StreamReader sr = new System.IO.StreamReader(Environment.CurrentDirectory + "\\system\\State\\" + this.myBotConfig._CharacterName);
string line = sr.ReadLine();
Logger.Log("CHECK CD KEYS: LINE = " + line);
if (line == null || line == "")
{
this.KeyListIndex = 0;
}
else
{
this.KeyListIndex = Convert.ToInt32(line) + 1;
}
sr.Close();
sr.Dispose();
if (this.KeyListIndex > this.myBotConfig._ClassicKeyList.Length - 1)
this.KeyListIndex = 0;
System.IO.StreamWriter sw = new System.IO.StreamWriter(Environment.CurrentDirectory + "\\system\\State\\" + this.myBotConfig._CharacterName, false);
sw.Write(this.KeyListIndex);
sw.Close();
sw.Dispose();
}
/// <summary>
/// will simply try to disconnect from the gameserver
/// </summary>
public void onRunDone()
{
Sleep(100);
byte[] GCExitGame = GameClient.ExitGame.Build();
try
{
myGameServerClient.GetStream().Write(GCExitGame, 0, GCExitGame.Length);
}
catch {}
Sleep(100);
try
{
myGameServerClient.Client.Shutdown(SocketShutdown.Both);
}
catch { }
Sleep(100);
try
{
myGameServerClient.Client.Close();
}
catch { }
Sleep(100);
myGameServerClient = null;
Sleep(100);
}
/// <summary>
/// Used to connect to battle.net
/// </summary>
/// <param name="botConfig">Somewhat redundant I can probably remove this (?)</param>
/// <returns>success or not</returns>
public bool ConnectToBattleNet(BotConfig botConfig)
{
CheckCdKeys();
Logger.Log("Connecting to battle.net...");
this.FatalDebugError = false;
this.LoginDone = false;
this.myBotConfig = botConfig;
myBnetServerClient = new TcpClient(this.GetServerString(this.myBotConfig._Server), 6112);
myBnetServerClient.LingerState = new LingerOption(true, 0);
if (myPacketSniffer != null)
{
myPacketSniffer.Dispose();
myPacketSniffer = null;
}
myPacketSniffer = new PacketSniffer();
myPacketSniffer.AddListener(D2Packets.PacketOrigin.BattleNetServer, new PacketEventHandler(this.onBnetPacketReceived));
myPacketSniffer.AddListener(D2Packets.PacketOrigin.RealmServer, new PacketEventHandler(this.onRealmPacketReceived));
myPacketSniffer.StartSniffing(Process.GetCurrentProcess().Id, myBotConfig._PcapName);
try
{
myBnetServerClient.GetStream().WriteByte(0x01);
myBnetServerClient.GetStream().Write(new BC.ConnectionRequest().Build(), 0, new BC.ConnectionRequest().Build().Length);
}
catch
{
this.NeedIPReset = true;
return false;
}
int Timeout = 0;
while (!this.FatalDebugError && !this.LoginDone)
{
System.Threading.Thread.Sleep(1);
if (Timeout > 5000)
{
Logger.Log("Failed to connect to battle.net: Timed out");
this.NeedIPReset = true;
return false;
}
Timeout++;
}
if (this.FatalDebugError)
{
Logger.Log("Failed to connect to battle.net");
return false;
}
this.NeedIPReset = false;
Logger.Log("We are now logged onto battle.net");
return true;
}
/// <summary>
/// Disconnect from battle.net
/// this function should maby check gameserver (?)
/// </summary>
public void Disconnect()
{
Logger.Log("Disconnecting from battle.net...");
this.onRunDone();
if (myRealmServerClient != null)
{
try
{
myRealmServerClient.Client.Shutdown(SocketShutdown.Both);
}
catch { }
Sleep(100);
try
{
myRealmServerClient.Client.Close();
}
catch { }
Sleep(100);
}
if (myBnetServerClient != null)
{
try
{
myBnetServerClient.Client.Shutdown(SocketShutdown.Both);
}
catch { }
Sleep(100);
try
{
myBnetServerClient.Client.Close();
}
catch { }
Sleep(100);
}
myRealmServerClient = null;
myBnetServerClient = null;
myGameServerClient = null;
}
void Disconnect_BnetServer()
{
if (myBnetServerClient != null)
{
try
{
myBnetServerClient.Client.Shutdown(SocketShutdown.Both);
}
catch { }
Sleep(100);
try
{
myBnetServerClient.Client.Close();
}
catch { }
Sleep(100);
}
}
void Disconnect_RealmServer()
{
this.onRunDone();
if (myRealmServerClient != null)
{
try
{
myRealmServerClient.Client.Shutdown(SocketShutdown.Both);
}
catch { }
Sleep(100);
try
{
myRealmServerClient.Client.Close();
}
catch { }
Sleep(100);
}
}
/// <summary>
/// Join a game. I need to change the return value to bool, it would be alot easier to use.
/// </summary>
/// <param name="GameNumber"></param>
/// <param name="GameName"></param>
/// <param name="GamePassword"></param>
void JoinGame(ushort GameNumber, string GameName, string GamePassword)
{
Logger.Log("Joining game: " + GameName);
byte[] myJoinGame = new data.RC.JoinGame(GameNumber, GameName, GamePassword).GetData();
Sleep(100);
myRealmServerClient.GetStream().Write(myJoinGame, 0, myJoinGame.Length);
}
/// <summary>
/// Create a game. I need to change the return value to bool, it would be alot easier to use.
/// </summary>
/// <param name="GameNumber"></param>
/// <param name="GameName"></param>
/// <param name="GamePassword"></param>
/// <param name="type"></param>
/// <param name="GameDescription"></param>
void CreateGame(ushort GameNumber, string GameName, string GamePassword,DifficultyType type,string GameDescription)
{
Logger.Log("Creating game: " + GameName);
byte[] myCreateGame = new data.RC.CreateGame(GameNumber, type, GameName, GamePassword, GameDescription).GetData();
Sleep(100);
myRealmServerClient.GetStream().Write(myCreateGame, 0, myCreateGame.Length);
}
/// <summary>
/// BNCS recv packets handler (event)
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void onBnetPacketReceived(object sender, PacketEventArgs args)
{
switch (args.Packet.Data[0])
{
case (int) D2Packets.BnetServerPacket.BnetPing:
BnetServer.BnetPing ping = args.Packet as BnetServer.BnetPing;
//Logger.Log("Bnet: Ping? " + ping.Timestamp);
uint Timestamp = ping.Timestamp;
BC.BasePacket pong = new data.BC.BasePacket(0x25);
pong.InsertUInt32(Timestamp);
byte[] raw = pong.GetData();
try
{
myBnetServerClient.GetStream().Write(raw, 0, raw.Length);
}
catch { }
//Logger.Log("Bnet: Pong!");
break;
case (int)D2Packets.BnetServerPacket.BnetConnectionResponse:
//0x50
//this.KeyListIndex += 1;
if (this.KeyListIndex >= myBotConfig._ClassicKeyList.Length)
this.KeyListIndex = 0;
Logger.Log("BNetConnectionResponse received");
BnetServer.BnetConnectionResponse packet = args.Packet as BnetServer.BnetConnectionResponse;
this.ClientToken = (uint)Environment.TickCount;
MBNCSUtil.DataReader myReader = new MBNCSUtil.DataReader(packet.Data);
myReader.Seek(7);
this.ServerToken = myReader.ReadUInt32();
//send 0x51
BC.AuthorizationCheck myAUTH_CHECK = new data.BC.AuthorizationCheck(ClientToken, packet.VersionFileName
, packet.VersionFormulae, myBotConfig._GameFiles, myBotConfig._ClassicKeyList[KeyListIndex]
, myBotConfig._LodKeyList[KeyListIndex], ServerToken, myBotConfig._OwnerName);
Logger.Log("Sending AuthorizationCheck for cdkey #" + KeyListIndex);
Sleep(50);
myBnetServerClient.GetStream().Write(myAUTH_CHECK.Build(), 0, myAUTH_CHECK.Build().Length);
break;
case (int)D2Packets.BnetServerPacket.BnetAuthResponse:
//0x51
BnetServer.BnetAuthResponse packet2 = args.Packet as BnetServer.BnetAuthResponse;
if (packet2.Result == BnetServer.BnetAuthResult.Success)
{
Logger.Log("Battle.net authorization success");
Logger.Log("Logging onto account: " + myBotConfig._AccountName);
Sleep(10);
byte[] accinfo = new BC.AccountInfo(myBotConfig._AccountName,myBotConfig._AccountPassword,(int)this.ClientToken,(int)this.ServerToken).Build();
myBnetServerClient.GetStream().Write(accinfo, 0, accinfo.Length);
}
else
{
Logger.Log("Could not pass battle.net authorization check. Result: " + packet2.Result.ToString());
if (packet2.Result != BnetServer.BnetAuthResult.CDKeyInUse)
{
this.NeedIPReset = true;
Logger.Log("BAD CDKEY DETECTED AT INDEX " + this.KeyListIndex);
};
this.FatalDebugError = true;
}
break;
case (int) D2Packets.BnetServerPacket.BnetLogonResponse:
//0x3a
BnetServer.BnetLogonResponse packet3 = args.Packet as BnetServer.BnetLogonResponse;
if (packet3.Result == BnetServer.BnetLogonResult.Success)
{
Logger.Log("Account logon success");
//query a list of realms
MBNCSUtil.BncsPacket myQueryPacket = new MBNCSUtil.BncsPacket(0x40);
myBnetServerClient.GetStream().Write(myQueryPacket.GetData(), 0, myQueryPacket.GetData().Length);
}
else
{
Logger.Log("Could not log onto account. Result: " + packet3.Result);
this.FatalDebugError=true;
}
break;
case (int) D2Packets.BnetServerPacket.QueryRealmsResponse:
//0x40
BnetServer.QueryRealmsResponse packet4 = args.Packet as BnetServer.QueryRealmsResponse;
this.RealmServerString = packet4.Realms[0].Name;
//send a request for realm server logon
byte[] myRealmLogon = new data.BC.RealmLogon(this.RealmServerString,(int) this.ClientToken,(int) this.ServerToken).Build();
Sleep(50);
myBnetServerClient.GetStream().Write(myRealmLogon, 0, myRealmLogon.Length);
break;
case (int) D2Packets.BnetServerPacket.RealmLogonResponse :
//0x3e
BnetServer.RealmLogonResponse packet5 = args.Packet as BnetServer.RealmLogonResponse;
if (packet5.Result == BnetServer.RealmLogonResult.Success)
{
Logger.Log("Realm logon data received successfully");
RealmServerIp = packet5.RealmServerIP;
this.BNCSUniqueName = packet5.Username;
myRealmServerClient = new TcpClient();
myRealmServerClient.LingerState = new LingerOption(true, 0);
myRealmServerClient.Connect(RealmServerIp, 6112);
System.Threading.Thread.Sleep(10);
myRealmServerClient.GetStream().WriteByte(0x01);
System.Threading.Thread.Sleep(10);
byte[] tmpdata = new byte[packet5.Data.Length+1];
tmpdata[0] = 0x01;
for (int i = 0; i < packet5.Data.Length; i++)
tmpdata[i + 1] = packet5.Data[i];
RS.Logon alogon = new data.RS.Logon(tmpdata);
RSLogon = new RC.Logon(alogon).Build();
Sleep(50);
myRealmServerClient.GetStream().Write(RSLogon, 0, RSLogon.Length);
}
else
{
Logger.Log("Failed to log onto realm server");
this.FatalDebugError = true;
}
break;
default:
break;
}
}
/// <summary>
/// Realmserver recv packets handler (event)
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void onRealmPacketReceived(object sender, PacketEventArgs args)
{
switch (args.Packet.Data[0])
{
case (int) D2Packets.RealmServerPacket.RealmStartupResponse:
//0x01
RealmServer.RealmStartupResponse rsesponce = args.Packet as RealmServer.RealmStartupResponse;
if (rsesponce.Result == RealmServer.RealmStartupResult.Success)
{
Logger.Log("Realm logon success");
byte[] CharLogonPacket = new RC.CharacterLogon(myBotConfig._CharacterName).GetData();
System.Threading.Thread.Sleep(100);
myRealmServerClient.GetStream().Write(CharLogonPacket, 0, CharLogonPacket.Length);
this.LoginDone = true;
}
else
{
Logger.Log("Failed to log onto realm server. result: " + rsesponce.Result.ToString());
if (rsesponce.Result == RealmServer.RealmStartupResult.TemporaryIPBan)
this.NeedIPReset = true;
this.FatalDebugError = true;
}
break;
case (int)D2Packets.RealmServerPacket.JoinGameResponse:
//0x04
RealmServer.JoinGameResponse JoinResponse = args.Packet as RealmServer.JoinGameResponse;
Logger.Log("JoinGameResponse received. result: " + JoinResponse.Result.ToString());
if (JoinResponse == null)
{
Logger.Log("Failed to join game, Packet is null (WTF?)");
this.FailedToJoin = true;
return;
}
LastJoinResult = JoinResponse.Result;
if (JoinResponse.Result != RealmServer.JoinGameResult.Success)
{
Logger.Log("Failed to join game. Reason: " + JoinResponse.Result);
this.FailedToJoin = true;
if (JoinResponse.Result == RealmServer.JoinGameResult.GameDoesNotExist)
this.NeedIPReset = true;
return;
}
Logger.Log("Connecting to GameServer...");
myGameServerClient = new TcpClient();
myGameServerClient.LingerState = new LingerOption(true, 0);
if (myGameServerClient.Connected)
{
return;
}
myGameServerClient.Connect(JoinResponse.GameServerIP, 4000);
for (int c = 0; c < 1000 && !myGameServerClient.Connected; c++)
System.Threading.Thread.Sleep(1);
if (!myGameServerClient.Connected)
{
this.FailedToJoin = true;
Logger.Log("Failed to connect to gameserver");
return;
}
BC.NotifyJoin myNotifyJoin = new data.BC.NotifyJoin(CurrentGameName,CurrentGamePassword);
byte[] BSNotifyJoin = myNotifyJoin.GetData();//bug here retrieve like packet x10
try
{
myBnetServerClient.GetStream().Write(BSNotifyJoin, 0, BSNotifyJoin.Length);
}
catch
{
this.FailedToJoin = true;
return;
}
Sleep(50);
byte[] GCLogon = new GCp.GameLogon(JoinResponse.GameHash, JoinResponse.GameToken
, myBotConfig._CharacterClass, myBotConfig._CharacterName).GetData();
try
{
myGameServerClient.GetStream().Write(GCLogon, 0, GCLogon.Length);
}
catch
{
this.FailedToJoin = true;
return;
}
Sleep(50);
try
{
myGameServerClient.GetStream().WriteByte(0x6b);
}
catch
{
this.FailedToJoin = true;
return;
}
Sleep(50);
try
{
byte[] TestConnectionPacket = GameClient.SelectSkill.Build(D2Data.SkillType.Telekinesis,D2Data.SkillHand.Right);
myGameServerClient.GetStream().Write(TestConnectionPacket,0,TestConnectionPacket.Length);
}
catch
{
this.FailedToJoin = true;
return;
}
this.InGame = true;
break;
case (int)D2Packets.RealmServerPacket.CreateGameResponse:
//0x03
RealmServer.CreateGameResponse CreateResponse = args.Packet as RealmServer.CreateGameResponse;
if (CreateResponse.Result == RealmServer.CreateGameResult.Success)
{
JoinGame(CurrentGameNum, CurrentGameName, CurrentGamePassword);
}
else
{
Logger.Log("Failed to create game: " + CreateResponse.Result);
this.FatalDebugError = true;
}
break;
default:
break;
}
}
/// <summary>
/// Convert a Server enum used in botconfig to a server string used in TcpClient.Connect()
/// </summary>
/// <param name="server"></param>
/// <returns></returns>
string GetServerString(Server server)
{
switch (server)
{
case Server.Asia:
return "asia.battle.net";
case Server.Europe:
return "europe.battle.net";
case Server.UsEast:
return "useast.battle.net";
case Server.UsWest:
return "uswest.battle.net";
default:
throw new ApplicationException("GetServerString() unknown server passed to function");
}
}
/// <summary>
/// Non-Blocking sleep method
/// </summary>
/// <param name="delay"></param>
void Sleep(int delay)
{
int StartTime = Environment.TickCount;
while (true)
{
System.Threading.Thread.Sleep(1);
if (Environment.TickCount - StartTime >= delay)
return;
}
}
/// <summary>
/// This is more for debugging purpose. What is state IdentifyConnection?
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void myPacketSniffer_OnConnectionChange(object sender, D2Packets.ConnectionChangeEventArgs args)
{
Logger.Log("----------- CONNECTION CHANGED -----------");
Logger.Log("CONNECTION STATE: " + args.Type);
Game.GameInfo.RST = true;
}
}
}