/////////////////////////////////////////////////////////////////////////////////
// Item reinforce with stones
/////////////////////////////////////////////////////////////////////////////////
public void AlchemyStoneMain()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
Character.Alchemy.ItemList = new List <ObjData.slotItem>();
byte type = Reader.Byte();
if (type == 1)
{
try
{
Character.Alchemy.AlchemyThread.Abort();
client.Send(Packet.AlchemyCancel());
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
else if (type == 2)
{
Reader.Skip(1);
byte numitem = Reader.Byte();
Character.Alchemy.ItemList.Add(GetItem((uint)Character.Information.CharacterID, Reader.Byte(), 0));
Character.Alchemy.ItemList.Add(GetItem((uint)Character.Information.CharacterID, Reader.Byte(), 0));
}
Alchemy = new Timer(new TimerCallback(StartAlchemyStoneResponse), 0, 4500, 0);
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
void Request()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
if (Reader.Byte() == 1 && Reader.Byte() == 0)
{
PlayerMgr sys = Helpers.GetInformation.GetPlayer(Character.Network.TargetID);
sys.client.Send(Packet.Exchange_Cancel());
}
else
{
PlayerMgr sys = Helpers.GetInformation.GetPlayer(Character.Network.TargetID);
sys.client.Send(Packet.OpenExhangeWindow(1, Character.Information.UniqueID));
client.Send(Packet.OpenExhangeWindow(sys.Character.Information.UniqueID));
Character.Network.Exchange.Window = true;
Character.Network.Exchange.ItemList = new List <ObjData.slotItem>();
sys.Character.Network.Exchange.Window = true;
sys.Character.Network.Exchange.ItemList = new List <ObjData.slotItem>();
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void RenameParty()
{
try
{
//Create new packet reader
PacketReader reader = new PacketReader(PacketInformation.buffer);
//First integer is party id
int partyid = reader.Int32();
//Second integer is not needed
int NotNeeded = reader.Int32();
//Byte party type
byte ptype = reader.Byte();
//Byte party purpose
byte purpose = reader.Byte();
//Byte minimum level
byte minlevel = reader.Byte();
//Byte max level to enter party
byte maxlevel = reader.Byte();
//Party name lenght
short namel = reader.Int16();
//Party name each character is a word value using text3
string pname = reader.Text3();
//Create new packet writer
PacketWriter Writer = new PacketWriter();
//Add opcode to server packet
Writer.Create(OperationCode.SERVER_PARTY_CHANGENAME);
//Write static byte 1
Writer.Byte(1);
//Write party id
Writer.DWord(partyid);
//Write dword 0
Writer.DWord(0);
//Write party type
Writer.Byte(ptype);
//Write party purpose
Writer.Byte(purpose);
//Write party minimum level
Writer.Byte(minlevel);
//Write party max level
Writer.Byte(maxlevel);
//Write party name
Writer.Text3(pname);
//Send bytes to client
client.Send(Writer.GetBytes());
}
//If a error happens
catch (Exception ex)
{
//Write the exception to the log
}
}
public static void PlayerQuickBar(PacketWriter Writer, int ID)
{
PacketReader Reader = new PacketReader(System.IO.File.ReadAllBytes(Environment.CurrentDirectory + @"\PlayerData\Hotkey\" + ID + ".ClientSettings"));
byte amm = 0;
int[] skillid = new int[51];
byte[] slotn = new byte[51];
for (byte i = 0; i <= 50; i++)
{
slotn[i] = Reader.Byte();
if (slotn[i] != 0)
{
skillid[i] = Reader.Int32();
amm++;
}
else
{
Reader.Skip(4);
}
}
Writer.Byte(amm);
for (byte i = 0; i <= 50; i++)
{
if (slotn[i] != 0)
{
Writer.Byte(i);
Writer.Byte(slotn[i]);
Writer.DWord(skillid[i]);
}
}
Reader.Close();
}
/////////////////////////////////////////////////////////////////////////////////
// Friend add response
/////////////////////////////////////////////////////////////////////////////////
public void FriendAddResponse()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
int Inviterid = reader.Int32();
int Myid = reader.Int32();
byte State = reader.Byte();
reader.Close();
PlayerMgr sys = Helpers.GetInformation.GetPlayer(Inviterid);
if (sys != null)
{
if (State == 0)
{
//Declined
client.Send(Packet.FriendDecline(Character.Information.Name));
sys.client.Send(Packet.FriendDecline(Character.Information.Name));
}
else
{
//Accepted
sys.client.Send(Packet.FriendData(Myid, 2, Character.Information.Name, Character, false));
client.Send(Packet.FriendData(Inviterid, 2, sys.Character.Information.Name, sys.Character, false));
DB.query("INSERT INTO friends (owner,friend_name,model_info) VALUES ('" + Character.Information.CharacterID + "','" + sys.Character.Information.CharacterID + "','" + sys.Character.Information.Model + "')");
DB.query("INSERT INTO friends (owner,friend_name,model_info) VALUES ('" + sys.Character.Information.CharacterID + "','" + Character.Information.CharacterID + "','" + Character.Information.Model + "')");
}
}
}
catch (Exception ex)
{
Console.WriteLine("Friend Add Response Error {0}", ex);
Log.Exception(ex);
}
}
public void CharacterScreen()
{
//Wrap our function inside a catcher
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte type = Reader.Byte();
//Switch on byte type
switch (type)
{
case 1:
//WorldMgr.character creation
CharacterCreate();
break;
case 2:
//Character listening
CharacterListing();
break;
case 3:
//Character deletion
CharacterDelete();
break;
case 4:
//WorldMgr.character checking
CharacterCheck(PacketInformation.buffer);
break;
case 5:
//Character restoring
CharacterRestore();
break;
case 9:
//Character job information
CharacterJobInfo();
break;
case 16:
//Select job
CharacterJobPick(PacketInformation.buffer);
break;
default:
//We use this if we get a new case.
Console.WriteLine("Character Screen Type: " + type);
Disconnect("normal");
break;
}
//Close packet reader
Reader.Close();
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Private Message Open
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void PrivateMessageOpen()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
/////////////////////////////////////////////////////////////////////////////////////
byte type = Reader.Byte();
short typeget = (short)type;
Reader.Close();
DB ms = new DB("SELECT * FROM message WHERE receiver='" + Character.Information.Name + "' AND idinfo ='" + typeget + "'");
using (SqlDataReader reader = ms.Read())
{
while (reader.Read())
{
string messageinfo = reader.GetString(3);
client.Send(Packet.PrivateMessageOpen(type, messageinfo));
DB.query("UPDATE message SET status='1' WHERE receiver='" + Character.Information.Name + "' AND idinfo ='" + type + "'");
}
}
ms.Close();
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void MakeAlias()
{
try
{
///////////////////////////////////////////////////////////////////////////////////////////////////
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int id = Reader.Int32();
byte type = Reader.Byte();
short nLenght = Reader.Int16();
string name = Reader.String(nLenght);
///////////////////////////////////////////////////////////////////////////////////////////////////
Console.WriteLine(name);
DB ms = new DB("SELECT * FROM character_jobs WHERE job_alias='" + name + "'");
int checkjob = ms.Count();
///////////////////////////////////////////////////////////////////////////////////////////////////
client.Send(Packet.MakeAlias(name, type));
if (checkjob == 0)
{
client.Send(Packet.MakeAlias(name, type));
DB.query("UPDATE character_jobs SET job_alias='" + name + "' WHERE character_name='" + Character.Information.Name + "'");
}
else if (checkjob >= 0)
{
client.Send(Packet.MakeAliasError(name, type));
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Open Npc
/////////////////////////////////////////////////////////////////////////////////
public void Open_NPC()
{
#region Open Npc
try
{
Character.State.Busy = true;
PacketReader Reader = new PacketReader(PacketInformation.buffer);
Reader.UInt32();
byte type = Reader.Byte();
if (type == 1)
{
client.Send(Packet.OpenNPC(type));
}
else
{
client.Send(Packet.OpenNPC(type));
}
Reader.Close();
}
catch (Exception ex)
{
Log.Exception(ex);
}
#endregion
}
void MovementSkyClicking(PacketReader Reader)
{
Character.Position.Walking = true;
byte Type = Reader.Byte();
ushort Angle = Reader.UInt16();
Character.Information.Angle = (Angle) / 182.04166666666666;
Character.Position.packetxSec = Character.Position.xSec;
Character.Position.packetySec = Character.Position.ySec;
Character.Position.packetX = (ushort)Formule.gamex(Character.Position.x, Character.Position.xSec);
Character.Position.packetY = (ushort)Formule.gamex(Character.Position.y, Character.Position.ySec);
double Distance = Formule.gamedistance(Character.Position.x, Character.Position.y, Formule.gamex((float)Character.Position.packetX, Character.Position.xSec), Formule.gamey((float)Character.Position.packetY, Character.Position.ySec));
PacketWriter writer = new PacketWriter();
writer.Create(0xb021);
writer.DWord(Character.Information.UniqueID);
writer.Byte(0);
writer.Byte(Type);
writer.Word(Angle);
writer.Byte(1);
writer.Byte(Character.Position.xSec);
writer.Byte(Character.Position.ySec);
writer.Word(Character.Position.packetX);
writer.DWord(Character.Position.z);
writer.Word(Character.Position.packetY);
Send(writer.GetBytes());
Reader.Close();
StartSkyDromeTimer(1000);
}
public void CharacterCheck(byte[] buff)
{
//Wrap our function into a catcher
try
{
//Open our reader
PacketReader Reader = new PacketReader(buff);
byte ignored = Reader.Byte();
string name = Reader.Text();
Reader.Close();
if (CharacterCheck(name))
{
client.Send(Packet.CharacterName(4));
}
else
{
client.Send(Packet.ScreenSuccess(4));
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
void CharacterJobPick(byte[] buff)
{
//Wrap our function inside a catcher
try
{
//Open packet reader
PacketReader Reader = new PacketReader(buff);
Reader.Skip(1);
short namel = Reader.Int16();
string name = Reader.String(namel);
byte job = Reader.Byte();
Reader.Close();
//Anti hack check
string namecheck = DB.GetData("SELECT name FROM character WHERE account='" + Player.AccountName + "'", "name");
int jobcheck = Convert.ToInt32(DB.GetData("SELECT jobtype FROM users WHERE id='" + Player.AccountName + "'", "jobtype"));
//If the name check is succesfull and account has no job set.
if (jobcheck == 0 && namecheck.Length > 0)
{
//Write new job info
DB.query("UPDATE users SET jobtype='" + job + "' WHERE id='" + Player.AccountName + "'");
}
//Send visual confirmation
client.Send(Packet.CharacterJobSelection());
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void JoinMerc()
{
try
{
DB ms = new DB("SELECT * FROM character_jobs WHERE character_name='" + Character.Information.Name + "'");
int checkjob = ms.Count();
if (checkjob == 0)
{
/////////////////////////////////////////////////////////////////////////////////////
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int id = Reader.Int32();
byte type = Reader.Byte();
/////////////////////////////////////////////////////////////////////////////////////
client.Send(Packet.InfoUpdate(1, Character.Information.CharacterID, 0));
client.Send(Packet.JoinMerchant(id, type));
/////////////////////////////////////////////////////////////////////////////////////
DB.query("INSERT INTO character_jobs (character_name, job_type) VALUES ('" + Character.Information.Name + "','2')");
ms.Close();
}
else
{
// Not needed cant join job because excist
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void Connect()
{
//Wrap our function inside a catcher
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte type = Reader.Byte();
Reader.Skip(3);
string ID = Reader.Text();
string PW = Reader.Text();
Reader.Close();
//Set login result information
int LoginResult = LoginUser(ID, ref PW, ref Player, true);
//If the login is succesfull
if (LoginResult == 4)
{
//Send succes packet
client.Send(Packet.ConnectSuccess());
}
//If the login is wrong
else
{
//Disconnect the user
client.Disconnect(PacketInformation.Client);
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
///////////////////////////////////////////////////////////////////////////
// Grabpet settings
///////////////////////////////////////////////////////////////////////////
public void GrabPetSettings()
{
//Not worked on yet.
PacketReader Reader = new PacketReader(PacketInformation.buffer);
int petid = Reader.Int32();
byte type = Reader.Byte();
int settingsinfo = Reader.Int32();
client.Send(Packet.ChangePetSettings(1, petid, type, settingsinfo));
}
public void Gameguide()//Will need to read this byte by byte to get the id for the server to record for the chardata
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
bool Guideok = false;
int[] b1 = new int[8];
for (int b = 0; b < 8; ++b) //Reads Guide Data
{
b1[b] = Reader.Byte(); //Puts into a int Array
}
for (int gc = 0; gc < 8; ++gc)//This Checks The Last Send Guide Paket To Make Sure The Same Packet Is Not Read Twice
{
if (b1[gc] == Character.Guideinfo.Gchk[gc])
{
Guideok = false;//If Guide Packet Has Been Sent Will Return False
}
else
{
Guideok = true;//If Guide Packet Is New Will Retun True And Break
break;
}
}
if (Guideok)
{
for (int gc = 0; gc < 8; ++gc) // Guide Packet Check
{
Character.Guideinfo.Gchk[gc] = b1[gc]; //Adds Packet To Int Array
}
for (int gi = 0; gi < 8; ++gi) //Guide Packet Update For Save And Teleport,Return,Etc
{
Character.Guideinfo.G1[gi] = Character.Guideinfo.G1[gi] + b1[gi]; //Adds The Packet And Updates The Data
}
PacketWriter Writer = new PacketWriter(); //Writes the Packet Responce For Guide Window
Writer.Create(OperationCode.SERVER_SEND_GUIDE);
Writer.Byte(1);
for (int b = 0; b < 8; ++b)
{
Writer.Byte(b1[b]);
}
client.Send(Writer.GetBytes());
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public static void PlayerAutoPot(PacketWriter Writer, int ID)
{
PacketReader Reader = new PacketReader(System.IO.File.ReadAllBytes(Environment.CurrentDirectory + @"\PlayerData\AutoPotion\" + ID + ".ClientSettings"));
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Writer.Byte(Reader.Byte());
Reader.Close();
}
//##############################################################################
// Start timers voids
//##############################################################################
public void StartPvpTimer(int time)
{
//Need to add checks
PacketReader reader = new PacketReader(PacketInformation.buffer);
byte pvptype = reader.Byte();
if (Timer.Pvp != null)
{
Timer.Pvp.Dispose();
}
Timer.Pvp = new Timer(new TimerCallback(Player_Pvp_CallBack), 0, time, 0);
Send(Packet.PvpSystemWait(Character.Information.UniqueID));
Character.Information.PvpWait = true;
Character.Information.Pvptype = pvptype;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Private Message Delete
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void PrivateMessageDelete()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte messageid = Reader.Byte();
client.Send(Packet.DeletePrivateMessage(messageid));
DB.query("delete FROM message WHERE idinfo='" + messageid + "' AND receiver='" + Character.Information.Name + "'");
return;
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void Init()
{
byte[] _data = File.ReadAllBytes(this.fileName);
reader = new PacketReader(_data);
files = new List <XfsFileData>();
#region HeaderInfo
offset = reader.Int32();
reader.Offset(offset);
zsize = reader.Byte();
info_size = zsize * 0x80;
byte[] head_data_com = reader.Bytes(zsize);
//Console.WriteLine(Utils.HexDump(head_data_com));
byte[] head_data_des = ZlibStream.UncompressBuffer(head_data_com);
//Console.WriteLine(Utils.HexDump(head_data_des));
PacketReader head_data = new PacketReader(head_data_des);
str_head = head_data.String(4);
version = head_data.Int32();
files_count = head_data.Int32();
validation = head_data.Int32();
offset2 = head_data.Int32();
#endregion
#region data_info
byte[] size_24bts = reader.Bytes(3);
int info_size_data = size_24bts[0] + (size_24bts[1] << 8) + (size_24bts[2] << 16);
//Console.WriteLine("info_size_data: {0}", info_size_data);
byte[] info_data_com = reader.Bytes(info_size_data);
byte[] info_data = ZlibStream.UncompressBuffer(info_data_com);
//Console.WriteLine(Utils.HexDump(info_data));
PacketReader reader_info = new PacketReader(info_data);
for (int cx = 0; cx < files_count; cx++)
{
XfsFileData fdata = new XfsFileData();
fdata.fileName = reader_info.String(true);
fdata.offset = reader_info.Int32();
fdata.compresed = reader_info.Int32();
fdata.UCSize = reader_info.Int32();
fdata.CSize = reader_info.Int32();
//Console.WriteLine("fileName: '{0}' offset_file: 0x{1:X} compresed: {2} UCSize: {3} CSize: {4}", fdata.fileName, fdata.offset, fdata.compresed, fdata.UCSize, fdata.CSize);
files.Add(fdata);
}
#endregion
}
void HandleRegisterIcon()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
byte type = reader.Byte();
int iconlenght = reader.Int32();
string icon = reader.Text();
reader.Close();
string convertedicon = ConvertToHex(icon);
//Save output to .dat file in hex formatting.
}
catch (Exception ex)
{
Console.WriteLine("Guild icon register error {0}", ex);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Player Actions / Sit / Stand / Walk etc
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void Doaction()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
List <int> toall = Character.Spawn;
byte type = Reader.Byte();
switch (type)
{
case 2:
if (Character.Transport.Right)
{
Send(toall, Packet.SetSpeed(Character.Transport.Horse.UniqueID, Character.Transport.Horse.Speed1, Character.Transport.Horse.Speed2));
Send(toall, Packet.ChangeStatus(Character.Transport.Horse.UniqueID, type, 0));
}
Send(toall, Packet.ChangeStatus(Character.Information.UniqueID, type, 0));
break;
case 3:
if (Character.Transport.Right)
{
Send(toall, Packet.SetSpeed(Character.Transport.Horse.UniqueID, Character.Transport.Horse.Speed1, Character.Transport.Horse.Speed2));
Send(toall, Packet.ChangeStatus(Character.Transport.Horse.UniqueID, type, 0));
}
Send(toall, Packet.ChangeStatus(Character.Information.UniqueID, type, 0));
break;
case 4:
SitDown();
break;
default:
Send(toall, Packet.ChangeStatus(Character.Information.UniqueID, type, 0));
break;
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
void CharacterRestore()
{
//Wrap our function in a catcher
try
{
//Open packet readers
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte unused = Reader.Byte();
string name = Reader.Text();
Reader.Close();
//Update database information set delete time to 0
DB.query("UPDATE character SET deletedtime=0 WHERE name='" + name + "'");
//Update visually screen with packet
client.Send(Packet.ScreenSuccess(5));
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
void CharacterDelete()
{
//Wrap our function in a catcher
try
{
//Open our reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte unused = Reader.Byte();
string name = Reader.Text();
Reader.Close();
//Update character deletion information
DB.query("UPDATE character SET deletedtime=dateadd(dd,7,getdate()) WHERE name='" + name + "'");
//Update character visual screen
client.Send(Packet.ScreenSuccess(3));
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public static void ClientCheck(Definitions.Clientdefinition sys)
{
PacketReader Reader = new PacketReader(sys.PacketInformation.buffer);
byte Locale = Reader.Byte();
string Name = Reader.Text();
int Version = Reader.Int32();
Reader.Close();
try
{
if (Name == "SR_Client")
{
sys.client.Send(Core.Packets.Connect._1());
sys.client.Send(Core.Packets.Connect._2());
sys.client.Send(Core.Packets.Connect._3());
sys.client.Send(Core.Packets.Connect._4());
sys.client.Send(Core.Packets.Connect._5());
if (Version == Definitions.Serverdef.SilkroadClientVersion)//
{
sys.client.Send(Core.Packets.Connect.ActualVersion());
}
else if (Version < Definitions.Serverdef.SilkroadClientVersion - 1)//
{
sys.client.Send(Core.Packets.Connect.ClientIsToOld());
}
else if (Version > Definitions.Serverdef.SilkroadClientVersion)//
{
sys.client.Send(Core.Packets.Connect.ClientIsToNew());
}
else
{
//sys.client.Send(Patch.SendPatchFiles());
}
}
}
catch (Exception error)
{
Console.WriteLine("Connect.cs Error: {0}", error);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Pet movement
/////////////////////////////////////////////////////////////////////////////////
public void MovementPet()
{
try
{
//Open our packet reader
PacketReader Reader = new PacketReader(PacketInformation.buffer);
//This one happens to all pets.
int petid = Reader.Int32();
//We switch on type (2 = attack pet, 1 = horse).
byte type = Reader.Byte();
switch (type)
{
//Horse pet movement
case 1:
byte movetype = Reader.Byte();
byte xsec = Reader.Byte();
byte ysec = Reader.Byte();
float x = Reader.Int16();
float z = Reader.Int16();
float y = Reader.Int16();
Reader.Close();
//Make sure attack timer is gone
StopAttackTimer();
//Set pickup to false
Character.Action.PickUping = false;
//Set movement active
Character.Position.Walking = true;
double distance = Formule.gamedistance(Character.Position.x,
Character.Position.y,
Formule.gamex(x, xsec),
Formule.gamey(y, ysec));
Character.Position.xSec = xsec;
Character.Position.ySec = ysec;
Character.Position.wX = Formule.gamex(x, xsec) - Character.Position.x;
Character.Position.wZ = z;
Character.Position.wY = Formule.gamey(y, ysec) - Character.Position.y;
Character.Position.packetxSec = xsec;
Character.Position.packetySec = ysec;
Character.Position.packetX = (ushort)x;
Character.Position.packetZ = (ushort)z;
Character.Position.packetY = (ushort)y;
Send(Packet.Movement(new ObjData.vektor(petid, x, z, y, xsec, ysec)));
break;
//Attack pet movement
case 2:
//Set pet info
Character.Attackpet.Details.x = Character.Position.x;
Character.Attackpet.Details.y = Character.Position.y;
Character.Attackpet.Details.z = Character.Position.z;
Character.Attackpet.Details.xSec = Character.Position.xSec;
Character.Attackpet.Details.ySec = Character.Position.ySec;
//Target id information
int targetid = Reader.Int32();
Reader.Close();
//Set pet speed information
Send(Packet.SetSpeed(petid, 50, 100)); //Need to make correct speed info later
//Check distances / target detailed.
//Send attack packet (new void pet attack to be created).
break;
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
public void StallBuy()
{
try
{
if (!Character.Network.Stall.isOpened)
{
return;
}
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte stallslot = Reader.Byte();
WorldMgr.stall currentStall = Character.Network.Stall;
WorldMgr.stall.stallItem sitem = currentStall.ItemList.Find(i => (i.stallSlot == stallslot));
// stall buyer update
byte slot = GetFreeSlot();
if (slot <= 12)
{
return;
}
if (Character.Information.Gold >= (long)sitem.price)
{
Character.Information.Gold -= (long)sitem.price;
client.Send(Packet.UpdateGold(Character.Information.Gold));
SaveGold();
}
else
{
return; //insufficent gold
}
// staller update
if (currentStall.ItemList.Contains(sitem))
{
PlayerMgr staller = Helpers.GetInformation.GetPlayer(currentStall.ownerID);
staller.Character.Information.Gold += (long)sitem.price;
staller.client.Send(Packet.UpdateGold(staller.Character.Information.Gold));
DB.query("update character set gold='" + staller.Character.Information.Gold + "' where id='" + staller.Character.Information.CharacterID + "'");
//DB.query("delete from char_items where itemnumber='item" + sitem.Item.Slot + "' AND owner='" + staller.Character.Information.CharacterID + "'");
DB.query("UPDATE char_items SET owner='" + Character.Information.CharacterID + "',slot='" + slot + "',itemnumber='item" + slot + "' WHERE owner='" + staller.Character.Information.CharacterID + "' AND itemid='" + sitem.Item.ID + "' AND id='" + sitem.Item.dbID + "' AND storagetype='0'");
//take item out from stall
if (currentStall.ItemList.Count == 1)
{
staller.Character.Stall.Stallactive = false;
Character.Stall.Stallactive = false;
}
currentStall.ItemList.Remove(sitem);
client.Send(Packet.StallBuyItem(stallslot, 1));
currentStall.Send(Packet.StallBuyItem2(Character.Information.Name, stallslot, currentStall.ItemList));
}
else
{
Disconnect("ban");
Console.WriteLine("Autobanned user: "******" Due to hacking");
}
}
catch (Exception ex)
{
Log.Exception(ex);
}
}
void MovementNormalClicking(PacketReader Reader)
{
float XPosition = 0;
float YPosition = 0;
float ZPosition = 0;
byte xsec = Reader.Byte();
byte ysec = Reader.Byte();
double Distance = 0;
Character.Position.Walking = true;
if (!FileDB.CheckCave(xsec, ysec))
{
XPosition = Reader.Int16();
ZPosition = Reader.Int16();
YPosition = Reader.Int16();
Distance = Formule.gamedistance(Character.Position.x, Character.Position.y, Formule.gamex(XPosition, xsec), Formule.gamey(YPosition, ysec));
Character.Position.xSec = xsec;
Character.Position.ySec = ysec;
Character.Position.wX = Formule.gamex(XPosition, xsec) - Character.Position.x;
Character.Position.wZ = ZPosition;
Character.Position.wY = Formule.gamey(YPosition, ysec) - Character.Position.y;
Character.Position.packetxSec = xsec;
Character.Position.packetySec = ysec;
Character.Position.packetX = (ushort)XPosition;
Character.Position.packetZ = (ushort)ZPosition;
Character.Position.packetY = (ushort)YPosition;
if ((xsec != 0) && (ysec != 0))
{
Send(Packet.Movement(new ObjData.vektor(Character.Information.UniqueID, XPosition, ZPosition, YPosition, xsec, ysec)));
}
StartMovementTimer(GetMovementTime(Distance));
}
else
{
XPosition = Formule.cavegamex((float)Reader.Int16(), (float)Reader.Int16());
ZPosition = Formule.cavegamez((float)Reader.Int16(), (float)Reader.Int16());
YPosition = Formule.cavegamey((float)Reader.Int16(), (float)Reader.Int16());
Distance = Formule.gamedistance(Character.Position.x, Character.Position.y, Formule.cavegamex(XPosition), Formule.cavegamey(YPosition));
Character.Position.xSec = xsec;
Character.Position.ySec = ysec;
Character.Position.wX = Formule.cavegamex(XPosition) - Character.Position.x;
Character.Position.wZ = ZPosition;
Character.Position.wY = Formule.cavegamey(YPosition) - Character.Position.y;
Character.Position.packetxSec = xsec;
Character.Position.packetySec = ysec;
Character.Position.packetX = (ushort)XPosition;
Character.Position.packetZ = (ushort)ZPosition;
Character.Position.packetY = (ushort)YPosition;
if ((xsec != 0) && (ysec != 0))
{
Send(Packet.Movement(new ObjData.vektor(Character.Information.UniqueID, XPosition, ZPosition, YPosition, xsec, ysec)));
}
StartMovementTimer(GetMovementTime(Distance));
}
Reader.Close();
if (Character.Grabpet.Active)
{
Send(Packet.Movement(new ObjData.vektor(Character.Grabpet.Details.UniqueID, XPosition + Rnd.Next(10, 15), ZPosition, YPosition + Rnd.Next(10, 15), xsec, ysec)));
}
if (Character.Attackpet.Active)
{
Send(Packet.Movement(new ObjData.vektor(Character.Attackpet.Details.UniqueID, XPosition + Rnd.Next(10, 15), ZPosition, YPosition + Rnd.Next(10, 15), xsec, ysec)));
}
}
public void Connect()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
if (Reader.Byte() == 18)
{
string ID = Reader.Text();
string PW = Reader.Text();
byte ukn = Reader.Byte(); // 0xff
UInt16 ServerID = Reader.UInt16();
int lResult = 99;
//Console.WriteLine("Id:{0} Pass:{1} ServerID:{2}",ID,PW,ServerID);
SRX_Serverinfo SSI = GSList[ServerID];
if (SSI != null)
{
UInt16 myKey = 0;
string sReason = "";
lock (Program.IPCResultList)
{
myKey = Program.IPCNewId++;
}
byte[] rqp = Program.IPCServer.PacketRequestLogin(Program.IPCPort, ID, PW, myKey);
Servers.IPCenCode(ref rqp, SSI.code);
lock (Program.IPCResultList)
{
Program.IPCResultList.Add(myKey, new IPCItem());
Program.IPCResultList[myKey].resultCode = 0x8000;
}
Program.IPCServer.Send(SSI.ip, SSI.ipcport, rqp);
DateTime tOut = DateTime.Now.AddSeconds(30);
while ((tOut >= DateTime.Now) && (Program.IPCResultList[myKey].resultCode == 0x8000) && (client.clientSocket.Connected))
{
System.Threading.Thread.Sleep(10);
}
lResult = Program.IPCResultList[myKey].resultCode;
sReason = Program.IPCResultList[myKey].banReason;
lock (Program.IPCResultList)
{
Program.IPCResultList[myKey] = null;
Program.IPCResultList.Remove(myKey);
}
rqp = null;
//Console.WriteLine("Resultado de login: {0}",lResult);
switch (lResult)
{
case 0:
if (SSI.lan_wan)
{
client.Send(ConnectSucces(SSI.wan, SSI.port, 1));
}
else
{
client.Send(ConnectSucces(SSI.ip, SSI.port, 1));
}
return;
case 1:
if (WrongPassword < 3)
{
client.Send(WrongInformation());
WrongPassword++;
return;
}
else
{
client.Disconnect(PacketInformation.Client);
return;
}
case 2:
client.Send(ServerIsFull());
client.Disconnect(PacketInformation.Client);
return;
case 3:
client.Send(AllreadyConnected());
client.Disconnect(PacketInformation.Client);
return;
case 4:
client.Send(BannedUser(sReason));
client.Disconnect(PacketInformation.Client);
return;
default:
if (lResult == 0x8000)
{
Console.WriteLine("[IPC] Timeout");
}
else
{
Console.WriteLine("[IPC] Result unknown {0}", lResult);
}
return;
}
}
else
{
Console.WriteLine("F**k No fun.. SSI");
}
}
}
catch (Exception ex)
{
Console.WriteLine("Connection Error: " + ex);
}
}
/////////////////////////////////////////////////////////////////////////////////
// Movement
/////////////////////////////////////////////////////////////////////////////////
public void Movement()
{
try
{
//foreach (var item in ObjData.Manager.MapObject)
//{
// for (int i2 = 0; i2 < ObjData.Manager.MapObject[item.Key].entitys.Count; i2++)
// {
// if (ObjData.Manager.MapObject[item.Key].entitys[i2].OutLines.Exists(te => te.PointA == Formule.packetx(Character.Position.x, Character.Position.xSec) && te.PointB == Formule.packety(Character.Position.y, Character.Position.ySec)))
// {
// Console.WriteLine("Çarpışma Bulundu");
// }
// else if (ObjData.Manager.MapObject[item.Key].entitys[i2].Points.Exists(te => te.x == Formule.packetx(Character.Position.x, Character.Position.xSec) && te.y == Formule.packety(Character.Position.y, Character.Position.ySec)))
// {
// Console.WriteLine("Çarpışma bulundu2");
// }
// }
//}
#region Check
Character.Action.Object = null;
Character.Action.nAttack = false;
Character.Action.Target = -1;
if (Timer.Pickup != null && Character.Action.PickUping)
{
StopPickupTimer();
}
if (Character.Information.SkyDroming)
{
StopSkyDromeTimer();
}
if (Character.Action.nAttack)
{
StopAttackTimer();
Character.Action.nAttack = false;
}
if (Character.Action.sAttack)
{
StopAttackTimer();
Character.Action.sAttack = false;
}
if (Character.Action.sCasting)
{
StopAttackTimer();
Character.Action.sCasting = false;
}
if (Character.Information.PvpWait)
{
Send(Packet.PvpInterupt(Character.Information.UniqueID));
Character.Information.PvpWait = false;
Character.Information.Pvptype = 0;
StopPvpTimer();
}
// returned
if (Character.Stall.Stallactive ||
Character.Information.SkyDroming ||
Character.State.Die ||
Character.State.Sitting ||
Character.Information.Scroll ||
Character.Action.sCasting ||
Character.Action.sAttack ||
Character.Action.nAttack)
{
return;
}
#endregion
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte MovementFlag = Reader.Byte();
if (MovementFlag == 0)
{
MovementSkyClicking(Reader);
}
if (MovementFlag == 1)
{
MovementNormalClicking(Reader);
}
}
catch (Exception exception)
{
Console.WriteLine("Movement error: {0}", exception);
}
}
void HandleRegisterIcon()
{
try
{
PacketReader reader = new PacketReader(PacketInformation.buffer);
byte type = reader.Byte();
int iconlenght = reader.Int32();
string icon = reader.Text();
reader.Close();
string convertedicon = ConvertToHex(icon);
//Save output to .dat file in hex formatting.
}
catch (Exception ex)
{
Console.WriteLine("Guild icon register error {0}", ex);
}
}
public void StallMain()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
byte Type = Reader.Byte();
//Item edit
if (Type == 1)
{
if (Character.Network.Stall.isOpened)
{
return;
}
byte stallslot = Reader.Byte();
Reader.Skip(2);
ulong price = Reader.UInt64();
if (price <= 999999999)
{
int StallItemIndex = Character.Network.Stall.ItemList.FindIndex(i => (i.stallSlot == stallslot));
Character.Network.Stall.ItemList[StallItemIndex].price = price;
Character.Network.Stall.Send(Packet.StallModifyItem(stallslot, price));
}
else
{
return;
}
}
//Add an item
else if (Type == 2)
{
if (Character.Network.Stall.isOpened)
{
return;
}
byte stallslot = Reader.Byte();
byte invpos = Reader.Byte();
short quantity = Reader.Int16();
ulong price = Reader.UInt64();
ObjData.slotItem uItemID = GetItem((uint)Character.Information.CharacterID, invpos, 0);
//Disable item mall items in stalls for now.
if (ObjData.Manager.ItemBase[uItemID.ID].Etctype == ObjData.item_database.EtcType.GLOBALCHAT ||
ObjData.Manager.ItemBase[uItemID.ID].Type == ObjData.item_database.ArmorType.AVATAR ||
ObjData.Manager.ItemBase[uItemID.ID].Type == ObjData.item_database.ArmorType.AVATARHAT ||
ObjData.Manager.ItemBase[uItemID.ID].Type == ObjData.item_database.ArmorType.AVATARATTACH
)
{
return;
}
if (quantity <= ObjData.Manager.ItemBase[uItemID.ID].Max_Stack)
{
WorldMgr.stall.stallItem StallItem = new WorldMgr.stall.stallItem();
LoadBluesid(uItemID.dbID);
StallItem.stallSlot = stallslot;
StallItem.price = price;
StallItem.Item = (GetItem((uint)Character.Information.CharacterID, invpos, 0));
if (Character.Network.Stall.ItemList.Exists((get => get.Item.dbID == StallItem.Item.dbID)))
{
return;
}
Character.Network.Stall.ItemList.Add(StallItem);
Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList));
}
else
{
return;
}
}
//Item pulling out
else if (Type == 3)
{
if (Character.Network.Stall.isOpened)
{
return;
}
byte stallslot = Reader.Byte();
//remove stallItem from stall
Character.Network.Stall.ItemList.Remove(Character.Network.Stall.ItemList.Find(i => (i.stallSlot == stallslot)));
Character.Network.Stall.Send(Packet.StallItemMain(Character.Network.Stall.ItemList));
}
//Stall modify state
else if (Type == 5)
{
byte State = Reader.Byte();
Character.Network.Stall.isOpened = (State == 1) ? true : false;
Character.Network.Stall.Send(Packet.StallSetState(State));
}
//Set Welcome msg
else if (Type == 6)
{
if (Character.Network.Stall.isOpened)
{
return;
}
short length = Reader.Int16();
Character.Network.Stall.WelcomeMsg = Reader.Text3();
//Console.WriteLine("New Welcome msg:" + welcome);
Character.Network.Stall.Send(Packet.StallWelcome(Character.Network.Stall.WelcomeMsg));
}
//Set StallName
else if (Type == 7)
{
string stallname = Reader.Text3();
Send(Packet.StallNameGlobal(Character.Information.UniqueID, stallname));
Character.Network.Stall.Send(Packet.StallName(stallname));
}
}
catch (Exception ex)
{
Console.WriteLine("Additem Stall error: {0}", ex);
}
}
/////////////////////////////////////////////////////////////////////////
//Guild Permissions
/////////////////////////////////////////////////////////////////////////
void GuildPermissions()
{
try
{
PacketReader Reader = new PacketReader(PacketInformation.buffer);
Reader.Byte();
int memberid = Reader.Int32();
byte permissions = (byte)Reader.Int32();
char[] bits = new char[8];
for (int i = 0; i < 8; ++i) bits[i] = (char)0;
bits = Convert.ToString(permissions, 2).ToCharArray();
Reader.Close();
// set the amount to the target player :)
int targetindex = Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == memberid);
if (Character.Network.Guild.MembersInfo[targetindex].Online)
{
Systems member = GetPlayerMainid(memberid);
// so here we can set chars right
member.Character.Network.Guild.joinRight = bits[4] == '1' ? true : false;
member.Character.Network.Guild.withdrawRight = bits[3] == '1' ? true : false;
member.Character.Network.Guild.unionRight = bits[2] == '1' ? true : false;
member.Character.Network.Guild.guildstorageRight = bits[0] == '1' ? true : false;
member.Character.Network.Guild.noticeeditRight = bits[1] == '1' ? true : false;
}
// set new amount to every guild members guild class
foreach (int m in Character.Network.Guild.Members)
{
int index = Character.Network.Guild.MembersInfo.FindIndex(i => i.MemberID == m);
if (Character.Network.Guild.MembersInfo[index].Online)
{
Systems sys = Helpers.GetInformation.GetPlayerMainid(m);
// here comes the messy way
Global.guild_player mygp = new Global.guild_player();
int myindex = 0;
foreach (Global.guild_player gp in sys.Character.Network.Guild.MembersInfo)
{
if (gp.MemberID == memberid)
{
mygp = gp; //
mygp.joinRight = bits[4] == '1' ? true : false;
mygp.withdrawRight = bits[3] == '1' ? true : false;
mygp.unionRight = bits[2] == '1' ? true : false;
mygp.guildstorageRight = bits[0] == '1' ? true : false;
mygp.noticeeditRight = bits[1] == '1' ? true : false;
break;
}
myindex++;
}
sys.Character.Network.Guild.MembersInfo[myindex] = mygp;
}
}
DB.query("UPDATE guild_members SET guild_perm_join='" + bits[4] + "',guild_perm_withdraw='" + bits[3] + "',guild_perm_union='" + bits[2] + "',guild_perm_storage='" + bits[0] + "',guild_perm_notice='" + bits[1] + "' WHERE guild_member_id='" + memberid + "'");
Character.Network.Guild.Send(Packet.GuildUpdate(Character, 4, 0, permissions, 0));
}
catch (Exception ex)
{
Console.WriteLine("Guild permission error: {0}", ex);
Log.Exception(ex);
}
}
