public static void Speak(this Extension E, PlayerSpeakEventArgs e, HSpeech Speech)
{
try
{
switch (Speech)
{
case HSpeech.Say:
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostSay, e.Message, e.Theme.Juice(), 0));
break;
case HSpeech.Shout:
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostShout, e.Message, e.Theme.Juice()));
break;
case HSpeech.Whisper:
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostWhisper, e.Message, e.Theme.Juice())); //This will DC you COME BACK TO THIS
break;
default:
break;
}
}
catch (Exception error)
{
MessageBox.Show(error.ToString());
}
}
public void VerifyPrimes(string prime, string generator)
{
_keyExchange.VerifyDHPrimes(prime, generator);
_keyExchange.Padding = PKCSPadding.RandomByte;
_main.LogInfo("GenerateSecretKey: " + Headers.OutGenerateSecretKey);
SendToServer(HMessage.Construct(Headers.OutGenerateSecretKey, _keyExchange.GetPublicKey()));
//SendToServer(HMessage.Construct(Headers.OutGe))
}
public void GenerateSecretKey(string publicKey)
{
_crypto = new RC4(_keyExchange.GetSharedKey(publicKey));
SendToServer(_crypto.Parse(HMessage.Construct(Headers.ClientVariables, 401, Headers.Variables.ClientVariables_1, Headers.Variables.ClientVariables_2)));
SendToServer(_crypto.Parse(HMessage.Construct(Headers.MachineID, GenMid(), "WIN/30,0,0,154")));
SendToServer(_crypto.Parse(HMessage.Construct(Headers.SSOTicket, _sso, _rand.Next(400, 4600))));
SendToServer(_crypto.Parse(HMessage.Construct(Headers.RequestUserData)));
IsConnected = true;
_main.LogSucess($"[BOT {Id}] Connected");
}
public static void ChangeClothes(this Extension E, IHPlayerData player)
{
if (player.Gender == HGender.Male)
{
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostChangeClothes, HGender.Male.ToString()[0], player.FigureId));
}
else
{
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostChangeClothes, HGender.Female.ToString()[0], player.FigureId));
}
}
public async void Connect()
{
//if(_proxyServer != null)
////_server.SOCKS5EndPoint = new IPEndPoint(IPAddress.Parse(_proxyServer), _proxyPort);
/*try
* {
* Socket Client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
* Client.NoDelay = true;
* IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse("3.210.175.39"), 38101);
* IAsyncResult result = Client.BeginConnect(endPoint, null, null);
* await Task.Factory.FromAsync(result, Client.EndConnect).ConfigureAwait(false);
* }
* catch( Exception ex)
* {
* MessageBox.Show(ex.ToString());
* }*/
_server = HNode.ConnectNewAsync("game-us.habbo.com", 38101).Result;
while (_server == null)
{
;
}
if (_server.IsConnected)
{
_main.LogSucess("Connected to habbo server");
}
HMessage releaseVerMsg = new HMessage(HMessage.ToBytes("{l}{u:4000}{s:PRODUCTION-202004272205-912004688}{s:FLASH}{i:1}{i:0}"));
await _server.SendPacketAsync(releaseVerMsg);
HMessage initCryptoMsg = new HMessage(HMessage.Construct(178, HMessage.ToBytes("[0][0][0][2][0]²")));
await _server.SendPacketAsync(initCryptoMsg);
//await _server.SendPacketAsync(Headers.ReleaseVersion, Headers.Variables.Production, "FLASH", 1, 0);
//await _server.SendPacketAsync(Headers.InitCrypto);
HMessage packet = await _server.ReceivePacketAsync().ConfigureAwait(false);
while (packet == null)
{
;
}
HandlePacket(packet);
//Listen();
}
public int SendToServer(ushort header, params object[] chunks)
{
return(SendToServer(HMessage.Construct(header, HDestination.Server, HProtocol.Modern, chunks)));
}
public static void SendMessage(this Extension E, PlayerSendMessageEventArgs e)
{
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostSendMessage, e.PlayerID, e.Message));
}
public int SendToServer(ushort header, params object[] chunks)
{
return(SendToServer(HMessage.Construct(header, chunks)));
}
public Task <int> SendToServerAsync(ushort header, params object[] values)
{
return(SendToServerAsync(HMessage.Construct(header, values)));
}
public void Respect(int id)
{
SendToServerCrypto(HMessage.Construct(Headers.RoomUserGiveRespect, id));
}
public void Dance(bool status)
{
SendToServerCrypto(HMessage.Construct(Headers.RoomUserDance, status ? 1 : 0));
}
public void LoadRoom(int room)
{
SendToServerCrypto(HMessage.Construct(Headers.RequestRoomLoad, room, "", -1));
}
public void ChangeClothes(string figureId)
{
SendToServerCrypto(HMessage.Construct(Headers.UserSaveLook, "M", figureId));
}
public static void Dance(this Extension E, PlayerDanceEventArgs e)
{
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostDance, (int)e.Dance));
}
public static void ChangeMotto(this Extension E, string PlayerName, HHotel Hotel)
{
string Motto = SKore.GetPlayerMotto(PlayerName, Hotel);
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostChangeMotto, Motto));
}
public static void ChangeMotto(this Extension E, IHPlayerData player)
{
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostChangeMotto, player.Motto));
}
public static void ChangeClothes(this Extension E, string PlayerName, HHotel Hotel)
{
string FigureID = SKore.GetPlayerFigureId(PlayerName, Hotel);
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostChangeClothes, HGender.Male.ToString()[0], FigureID));
}
public static void Gesture(this Extension E, PlayerGestureEventArgs e)
{
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostGesture, (int)e.Gesture));
}
private void SendPong()
{
SendToServerCrypto(HMessage.Construct(Headers.Pong));
}
public static void Sign(this Extension E, PlayerSignEventArgs e)
{
E.Contractor.SendToServer(HMessage.Construct(Data.Default.HostSign, (int)e.Sign));
}
public void Shout(string msg)
{
SendToServerCrypto(HMessage.Construct(Headers.RoomUserShout, msg, 1));
}
public Task <int> SendPacketAsync(ushort id, params object[] values)
{
return(SendAsync(HMessage.Construct(id, values)));
}
public void WalkTo(int x, int y)
{
SendToServerCrypto(HMessage.Construct(Headers.RoomUserWalk, x, y));
}
/// <summary>
/// Sends data to the remote <see cref="HNode"/> using the specified header, and chunks in an asynchronous operation.
/// </summary>
/// <param name="header">The header to be used for the construction of the packet.</param>
/// <param name="chunks">The chunks/values that the packet will carry.</param>
/// <returns></returns>
public Task <int> SendToServerAsync(ushort header, params object[] chunks)
{
return(Remote.SendAsync(HMessage.Construct(header, chunks)));
}
public void Scratch(int petId)
{
SendToServerCrypto(HMessage.Construct(Headers.ScratchPet, petId));
}
/// <summary>
/// Sends data to the local <see cref="HNode"/> using the specified header, and chunks in an asynchronous operation.
/// </summary>
/// <param name="header">The header to be used for the construction of the packet.</param>
/// <param name="chunks">The chunks/values that the packet will carry.</param>
/// <returns></returns>
public Task <int> SendToClientAsync(ushort header, params object[] chunks)
{
return(Local.SendAsync(HMessage.Construct(header, chunks)));
}
public Task <int> SendToClientAsync(ushort header, params object[] chunks)
{
var inMessage = new HMessage(0, HMessage.Construct(header, chunks));
return(_externalContractor.SendAsync(inMessage.ToBytes()));
}
public Task <int> SendToServerAsync(ushort header, params object[] chunks)
{
var outMessage = new HMessage(1, HMessage.Construct(header, chunks));
return(_externalContractor.SendAsync(outMessage.ToBytes()));
}
public int SendToServer(ushort Header, params object[] Chunks)
{
return(SendToServer(HMessage.Construct(Header, HDestinations.Server, Protocol, Chunks)));
}
private void SendToAll(ushort Header, int Amount = 0, params object[] Chunks)
{
byte[] Data = HMessage.Construct(Header, HDestinations.Server, HProtocols.Modern, Chunks);
SendToAll(Data, Amount);
}
